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

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

presentation [clear filter]
Tuesday, May 12
 

11:00am

Parallel Computing: Strategies and Implications
Multi-core architecture is the present and future way in which the market is addressing Moore’s law limitations. Multi-core workstations, high performance computers, GPUs and the focus on hybrid/public cloud technologies for offloading and scaling applications is the direction development is heading.
Leveraging multiple cores in order to increase application performance and responsiveness is expected especially from classic high-throughput executions such as rendering, simulations and heavy calculations.
Choosing the correct multi-core strategy for your software requirements is essential. Making the wrong decision can have serious implications on software performance, scalability, memory usage and other factors.
In this overview we’ll explore various considerations for choosing the correct multi-core strategy for your application’s requirement and investigate the pros and cons of multi-threaded development vs multi-process development.
For example, Boost’s GIL (Generic Image Library) provides the ability to efficiently code image processing algorithms. But deciding whether your algorithms should be executed as multi-threaded or multi-process has a high impact on your design, coding, future maintenance, scalability, performance and other factors.
A partial list of considerations that should be taken into account before taking this architectural decision can look like:
• How big are the images I need to process 
• What risks can I have in terms of race-conditions, timing issues, sharing violations – does it justify multi-threading programming?
• Do I have any special communication and synchronization requirements?
• How much time would it take my customers to execute a large scenario?
• Would I like to scale processing performance by using the cloud or cluster?
In order to learn how this issue is being addressed in a real-world scenario, we will examine common development and testing environments we are using in our daily work and compare the multi-core strategies they’ve implemented in order to support higher development productivity.

Speakers
GS

Guy Shattah

Principle Engineer, Incredibuild (xoreax)
I am a veteran software engineer with expertise in the fields of multi-threaded, distributed development of mission critical real-time systems. such as storage, networking, security and more. | My Professional and academic experience is focused on innovations in the fields of high-availability... Read More →


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

11:00am

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

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

Slides 

Speakers
avatar for Ben Deane

Ben Deane

Ben was in the game industry for 23 years, at companies like EA and Blizzard. He's always looking for useful new techniques in C++, and hegeeks out on algorithms, APIs, types and functional programming.


Tuesday May 12, 2015 11:00am - 12:30pm
Flug Auditorium

11:00am

Your CPU Is Binary
The modern CPU is binary, which has so influenced the evolution of programming languages that software engineers think in bivalent (Boolean) logic and are sometimes blind to alternative systems. In contrast, three-value logic (3VL) is an example of multi-valued logic which is increasingly embraced on some modern hardware, such as for communications and memory storage.

This is principally a speculative discussion of the modern multi-core (binary) CPU as it is seen by the programmer, and how and why it may evolve to a 3VL CPU to achieve greater efficiencies, higher radix economy, and enable more correct software. A historical review is made of the ternary CPU, attention is drawn to problems with bivalent logic in creating APIs, and light discussion is made for how a practical transition may be made to ternary logic in source code, and the eventual effect it may have on the C++ language standard.

Slides 

Speakers
avatar for Charles Bay

Charles Bay

F5
Software developer with 25+ years experience in large-scale and distributed systems in performance-sensitive environments including real-time processing, performance visualization, embedded systems, time-sensitive processing of large data sets, hardware status-and-control, and instrument/process/sub-assembly... Read More →


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

2:30pm

Functional Geometry: Producing Pure Spaces
Continuing our investigation of generic compile-time synthesis of geometric spaces from last year's conference, we formalize our approach to designing a spatial computation engine using category theory and functional programming paradigms. We examine cartesian product spaces and develop a theory of computable movements, categorizing our geometric structs as we go, providing a case-study lesson in category theory, geometric algebra, differential geometry, C++ template metaprogramming, and generic lambdas. Specifically, we use C++14 to combine two formalisms: the first is Geometric Algebra, a mathematical system for multidimensional synthesis and analysis. It serves as a unifying substrate for modeling physical relationships in any dimension, and within any ambient metric. The second, Functional Programming, organizes the system of constructions, coincidences, and causes that generate our geometric world. With this union of form and process we demonstrate how morphing structures - kinematic chains, curved-crease origami, knotted weaves and braids, organic forms - can be deductively modeled by structured morphisms - algebras, monadic continuations, declarative constraint networks, and metaprogramming techniques. Developing these programmable abstractions into a C++ template library, we achieve a dimensional fluency - an ability to solve complex geometric problems visually and intuitively. The result is a compact, expressive and extendable system for articulating spatial configurations, and a potential contribution to the Boost library.

Slides 

Speakers
avatar for Pablo Colapinto

Pablo Colapinto

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


Tuesday May 12, 2015 2:30pm - 4:00pm
Bethe

2:30pm

Lessons Learned
A cornucopia of small insights, and the stories behind them, that attempt to explain how I code day to day. They work for me - I can only hope you find them insightful and helpful as well. Let's discuss!

Including:

- Commenting - Is the Queen of Clubs a Value or an Object? - Error handling - know your audience - How to NOT call assert - That one simple rule to writing better code NOW! - And more

Slides 

Speakers
avatar for Tony Van Eerd

Tony Van Eerd

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


Tuesday May 12, 2015 2:30pm - 4:00pm
Hudson

4:30pm

Yomm11: Open Multi-Methods for C++11
Open methods - virtual functions declared outside a class - solve many important problems: they make components more extensible; they help reduce coupling by allowing a better partitioning of responsibilities; and they solve the problem of sewing together layers in multi-tier architectures. Multi-methods - methods dispatched based on the dynamic type of more than one argument - sometimes come handy when dealing with situations like matrix addition or as a replacement for the Visitor pattern. Multi-methods extend to run time the multi-argument selection found in function overloading and template specialization.

A proposal to support open multi-methods was submitted by Bjarne Stroustrup and col. but failed to gain acceptance so far. C++11 makes it possible to support them in a library with a reasonable syntactic burden.

Slides 

Speakers
avatar for Jean-Louis Leroy

Jean-Louis Leroy

Senior Software Engineer, Bloomberg LP
I am the author of yomm2, a library that implements open multi-methods. See https://github.com/jll63/yomm2


Tuesday May 12, 2015 4:30pm - 6:00pm
Hudson

8:30pm

Boost 2.0
Boost’s original mission was to save C++ from extinction in the face of Java, C# et.al. by providing high quality enhancements to the C++ standard library. I argue that this mission has been accomplished, so that Boost needs a updated new mission. I will propose such a mission to motivate the continuing evolution of Boost and C++ over the next 10 years.  This will be to:
  • Facilitate creation of quality C++ libraries by and for a wider audience
  • Demonstrate standards and promote practices which result in quality code.
An evolution of mission will require changes Boost’s practices.  I will present specific proposals encompassing the following:
  • Reviews and review management
  • Library deployment and deprecation
  • Testing
  • Economic support for library development
By proposing specific mission and evolution of practices, I hope to provide a framework around which alternatives can be proposed and debated in the best of Boost tradition. Some other presentations at this conference touch on related themes.  I will invite presenters to refer to these topics in their own presentation and for other interested parties to make their own proposals in the “lightening talks” sessions later in the week. The goal is that by the last session - “The Future of Boost” we might have some consensus on where to take Boost in the coming decade.

Link to slides 

Speakers
avatar for Robert Ramey

Robert Ramey

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


Tuesday May 12, 2015 8:30pm - 10:00pm
Flug Auditorium
 
Wednesday, May 13
 

11:00am

On the design and Boost-based implementation of two new C++ libraries for atmospheric research
Atmospheric science has traditionally been one of the toughest strongholds of Fortran. This talk will summarise experiences from development of two C++ libraries aimed at the atmospheric community. The libmpdata++ [1] implements state-of-the-art numerics for partial differential equations. The libcloudph++ [2] features a collection of algorithms for modelling clouds and precipitation.

The story begins with obtaining research funding for software development, goes on to the design and implementation -- the focus of the presentation, and concludes with public peer-review of the journal-paper-structured documentation of the libraries. The libraries are free and open source software and were implemented using several C++ libraries including: Blitz++, Thrust, Boost.Units, Boost.Thread, Boost.odeint and Boost.Python. The talk will give details on how and why these libraries were used and how their use contributed to a level of maintainability hardly attainable with other languages.

Slides

[1]: http://libmpdataxx.igf.fuw.edu.pl [2]: http://libcloudphxx.igf.fuw.edu.pl

Speakers
avatar for Sylwester Arabas

Sylwester Arabas

Researcher, University of Warsaw
I work in the Atmospheric Physics Division, Faculty of Physics, University of Warsaw, Poland. I study aerosol, cloud, and precipitation microphysics, mostly by means of numerical modelling. | | I'm an atmospheric physicist by training working as a research software engineer... Read More →


Wednesday May 13, 2015 11:00am - 11:45am
Hudson

11:45am

Why in heaven there is no dependency management for C++?
C++ (and C) are the larger and older mainstream languages, but they lack an important devtool: a dependency manager, which other languages have.

This talk will analyse the state of the art, and deep dive into existing solutions, possible problems and difficulties and the possible implications for the future of the language.

Slides 

Speakers
avatar for Diego Rodriguez-Losada Gonzalez

Diego Rodriguez-Losada Gonzalez

SW Engineer, JFrog
Diego's passions are robotics and SW engineering and development. He has developed many years in C and C++ in the Industrial, Robotics and AI fields. Diego was also a University (tenure track) professor and robotics researcher for 8 years, till 2012, when he quit academia to try... Read More →


Wednesday May 13, 2015 11:45am - 12:15pm
Hudson

11:45am

Boost.Compute: A library for GPU/parallel-computing
Boost.Compute is a library for GPU/parallel-computing. It provides a high-level, STL-like API and is portable to a wide variety of parallel accelerators including GPUs, FPGAs, and multi-core CPUs. This talk will give an overview of the library and demonstrate how to write and execute high-performance C++ applications on modern GPU hardware.

Slides 

Speakers

Wednesday May 13, 2015 11:45am - 12:30pm
Flug Auditorium

2:30pm

Back to the Future
In today's computing, where multi-core is the new modality and parallelism is clearly here to stay, we have to look into finding higher level abstractions in C++ allowing to easily write applications which utilize all of the available parallelism. Ideally, those abstractions provide uniform access to various types of parallelism: be it local (shared memory), remote (distributed memory), or heterogeneous (using accelerators and coprocessors). The current work being done in the context of the C++ standardization efforts provides a good starting point, but is not sufficient to uniformly cover the bulk of those use cases. This talk will give an introduction to a reference implementation of a heterogeneous, and extensible future. We will focus on giving a walkthrough through the various components and showcase the general structure of our library by outlining specific implementation techniques ranging from general API design, serialization and high speed network support. This is in contrast to exisiting parallel programming models such as OpenMP or MPI which tend to be unable to fully exploit all available hardware resources. Especially for modern hardware architectures, and even more for the architectures to come, this poses a big challenge for application developers who want to fully employ the existing hardware resources. We will present results from our work on a new programming model targeting best possible application scalability. This programming model is maximally aligned with the current C++ standard and the related standards proposals. This ensures an easy learning curve for new programmers. We will demonstrate that this programming model enables to write application which consistently out-scale and out-perform existing ones. The resulting codes enable performance portability towards future architectures.

Slides 

Speakers
avatar for Agustin Berge

Agustin Berge

Fusion Fenix
Does C++ stuff.
avatar for Thomas Heller

Thomas Heller

Researcher, Friedrich-Alexander-University Erlangen-Nuremberg
Thomas is a member of the research staff at the institute for computer architectures at the Friedrich-Alexander-University Erlangen Nuremberg. His interests are in High Performance Computing, more specifically in how to exploit parallelism of current and new architectures, mainly... Read More →
HK

Hartmut Kaiser

STE||AR Group, Center for Computation and Technology
Hartmut is a member of the faculty at the CS department at Louisiana State University (LSU) and a senior research scientist at LSU's Center for Computation and Technology (CCT). He received his doctorate from the Technical University of Chemnitz (Germany) in 1988. He is probably best... Read More →


Wednesday May 13, 2015 2:30pm - 4:00pm
Hudson

4:30pm

New Build System for New C++
At CppCon 2014 I gave a lightning talk trying to convince the audience that C++ needed a package manager. As it turned out, no convincing was necessary. I was also surprised by the number of people who told me after the presentation how desperately they needed this. In particular, it made me realize that this is not only a problem for a relatively few cross-platform library developers but also for organizations that struggle to manage their build configurations on a single platform using one C++ compiler.

Once you start thinking about a cross-platform C++ package manager, it won't be long before you realize that you also need a cross-platform build system to match. And when it comes to the existing tools, things don't look very promising. The more I thought about this the clearer it became that in order to create a C++ package manager we will first need to solve the build system problem.

So in this talk I would like to present the design of the new C++ build system I am working on and show lots of examples. As it is still work in progress, I am looking to get feedback and hear your ideas as much as to show what I have done so far. The discussion and choice of a build system can often have a religious aspect to it. But we are not going to hide from that. So if you don't think we need yet another build system, come and convince us why the whole thing is a bad idea.

Slides 

Speakers
avatar for Boris Kolpackov

Boris Kolpackov

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


Wednesday May 13, 2015 4:30pm - 6:00pm
Flug Auditorium
 
Thursday, May 14
 

11:00am

A review of C++ 11/14 only Boost libraries - Fiber, AFIO, DI and APIBind
As yet, no official Boost library requires C++ 11 or 14, but there are such libraries in the pipeline - Fiber is conditionally approved, AFIO and DI are in the formal review queue, and APIBind will be entering the queue shortly after C++ Now. Why do these libraries require C++ 11 or 14? Could they have been implemented with C++ 03, and what sacrifices would have had to have been made to support 03? Or do they incorporate designs which would be impossible in an 03 compiler, maybe due to lack of language features or because meta-programming limits would make the design untenable or the library unusable? What C++ 11/14 features do these libraries use? Is there a common theme of the most popular C++ 11/14 features used, or is the use of the state of the art more patchy? Are there techniques used in one library which would make a lot of sense to be used in another library, but for some reason are not? Do these new libraries take notice of one another and integrate themselves well with other libraries, or are they ivory towers? How many of these forthcoming libraries explicitly seek to contribute to future C++ standardization, and how many are instead application libraries solving a particular problem domain? For those intended to contribute towards standardization, is there a theme e.g. are they about standardizing functional C++ programming into the standard? We'll explore these questions and more in a session that examines the future of Boost libraries with regard to language and STL requirements.

* Boost.Fiber: a framework for micro-/userland-threads (fibers) scheduled cooperatively.

* Boost.AFIO: strongly ordered asynchronous filesystem and file i/o extending ASIO.

* Boost.DI: provides compile time, macro free constructor dependency injection.

* Boost.APIBind: toolkit for modularizing Boost libraries, managing versioned API and ABI dependency binds, makes it easy for Boost libraries to switch between use of the C++ 11 STL and the Boost STL.

Slides 

Speakers
avatar for Niall Douglas

Niall Douglas

Consultant, ned Productions Ltd
Niall Douglas is a lead author of WiP Boost.AFIO v2, Boost.Outcome, Boost.KernelTest and Boost-lite. He has been the lead Google Summer of Code administrator for Boost since 2014. He is an Affiliate Researcher with the Waterloo Research Institute for Complexity and Innovation at the... Read More →


Thursday May 14, 2015 11:00am - 12:30pm
Hudson

11:00am

Robustness and Security Techniques with Modern C++
This session provides best practices for building secure and robust applications with modern C++ language features and toolchains. The emphasis is on integration of new language features such as strong enums, static assert, type inferencing, error codes, ... along with significant improvements in the toolchains such as improved static analysis the run-time address, thread, and undefined behavior sanitizers. We also discuss best practices for compiling and linking to harden the resulting libraries and executables including stack and heap protection, read-only stack, and use of fortified variant of the standard libraries.

The goal is to bring together a range of best practices into a single session and show how they can be integrated. There are a number of interesting build issues for maximizing productivity while maintain high security and robustness.



gleaned from several years of building retail point of sale applications.


Thursday May 14, 2015 11:00am - 12:30pm
Flug Auditorium

11:00am

Type-safe configuration library
There are many ways to implement a configuration library; some of them are "stringly-typed", some use boost::any to implement erasure and expose it in their interfaces, but I think that this just means that the abstractions are leaking. I don't want to know what specific type erasure implementation is used in the library; I don't want to deal with things like `any_cast`, and I definitely do not want to ever get `bad_any_cast` thrown at me.

So, I've created a library that allows you to create type-level tags for your data that's to be stored in the configuration object, so the checking for `bad_any_cast` is moved from runtime to compile time, and we all love compile time checks more than runtime ones. This talk is meant as a tour around the library and its features. I will also talk about Boost.TypeIndex library, and some metaprogramming tricks that make using `enable_if` less painful.

Slides


Speakers
avatar for Michał Dominiak

Michał Dominiak

System Software Engineer, Nvidia
Bachelor of Engineering in Computer Science from Wrocław University of Technology. Professional and enthusiast programmer. Interested in the foundational problems of computing, from the lowest levels of CPU architectures, through operating systems and programming language design... Read More →


Thursday May 14, 2015 11:00am - 12:30pm
Bethe

2:30pm

How we reason about procedural programs
As programmers, we reason about the behavior of programs routinely, and with a remarkable degree of correctness. But we rarely reflect on how we achieve this feat.

In this talk, I intend to shine a light on the fundamental principles of reasoning about procedural programs, examine the assumptions behind them, and describe some of the ways they combine to let us reason about complex programs.

Slides 

Speakers
avatar for Lisa Lippincott

Lisa Lippincott

Software Architect, Tanium
Lisa Lippincott designed the software architectures of Tanium and BigFix, two systems for managing large fleets of computers. She's also a language nerd, and has contributed to arcane parts of the C++ standard. In her spare time, she studies mathematical logic, and wants to make computer-checked... Read More →


Thursday May 14, 2015 2:30pm - 4:00pm
Hudson

2:30pm

Modern generic programming using the Tick and Fit libraries
C++ templates provide a very powerful abstraction for generic programming. Even so, they still suffer from long and confusing compile errors and this puts an extra burden of complexity on library writers who want to provide flexibility in their interfaces. In this talk, we will first discuss the importance of concept-based type requirements in code in order to produce clear compile errors, and how the Tick library can be used to specify and check those type requirements.

Later, we will discuss how the Fit library can further enhance generic programming. The Fit library provides many abstractions over functions including a way to do sophisticated overloading in a simple and concise manner. We will discuss in this talk how we can leverage these abstractions with overloading to provide simple and flexible interfaces. We will also look at comparison of these solutions with the Concepts Lite proposal and Boost.ConceptCheck.

Link to Materials
 ||| PDF File
 

Speakers
avatar for Paul Fultz II

Paul Fultz II

Software Engineer, AMD


Thursday May 14, 2015 2:30pm - 4:00pm
Bethe

4:30pm

Boostache Exposed - the internals of Boost's template engine
Template engines are commonly found generating web pages, customer reports, or even source code. They take a source template and data model as input and generate some desired output.

Boostache was started as the Library in a Week challenge from CppNow'14. It initially supported the mustache template format and a recursive variant based data model.

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

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

Slides 

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


Thursday May 14, 2015 4:30pm - 6:00pm
Bethe

4:30pm

Lock-free by Example: Towards an Interesting Lock-free MPMC Queue
An "interesting" lock-free queue? Well, "multi-producer, multi-consumer, growing, shrinking, mostly contiguous, lock-free circular queue" was a bit long. Maybe "complicated" is a better word.

The "towards" is a hint that we won't complete the queue in 90 minutes. But we can make progress, and along the way encounter (and hopefully solve) many of the typical problems found in lock-free programming, and delve into the pros and cons of various solutions to those problems.

Slides 

Speakers
avatar for Tony Van Eerd

Tony Van Eerd

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


Thursday May 14, 2015 4:30pm - 6:00pm
Flug Auditorium
 
Friday, May 15
 

9:00am

Debugging using an exact recording of a program's execution.
I'll be demonstrating and talking about Undo's Live Recorder. This is a library which allows Linux C++ applications to create 100% accurate recordings of their own execution in the field. Back at base, developers can load these recordings into the UndoDB reversible debugger, allowing them to use reversible debugging on their own machine to investigate failures at a customer site.

Having recordings of applications available and playable via a reversible debugger, allows new ways of working. For example one can compare two recordings using a binary search of their histories to see where they diverged, or have more than one developer work on an exact copy of the same bug at the same time. One can also use gdb's python extension system to programatically expore the history of the original application's execution. This allows things that were previously not considered possible, e.g. dataflow analysis is transformed if one can work backwards in time.

Speakers
avatar for Julian Smith

Julian Smith

Software Architect, Undo Software
Julian Smith is co-founder and Software Architect at Undo Software. He holds a physics degree from Oxford University and a Ph.D. in cognitive psychology from the University of Edinburgh. Along with co-founder and CEO Greg Law, Julian designed and developed Undo's patented record-and-rewind... Read More →


Friday May 15, 2015 9:00am - 10:30am
Bethe

9:00am

Details Matter
When writing a library for general consumption, even the smallest details start to matter, if you do not want to surprise a user with some unexpected behavior.

Alisdair Meredith will share some of the lesser known corners and details of the language that shed light on the standard library design and implementation. In particular, many implementation details risk exposure when writing generic code (templates) which happens to be most of the standard library.

Other topics include why it is important that a type thrown as an exception never throws from its copy constructor, the reference-counted string type hidden in the standard library, and why these two topics are more related than might first appear!

Slides 

Speakers
avatar for Alisdair Meredith

Alisdair Meredith

Senior Developer, BloombergLP
Alisdair Meredith is a software developer at BloombergLP in New York, and the C++ Standard Committee Library Working Group chair.He has been an active member of the C++ committee for just over a decade, and by a lucky co-incidence his first meeting was the kick-off meeting for the... Read More →


Friday May 15, 2015 9:00am - 10:30am
Hudson

11:00am

Parallelizing the Standard Template Library(STL)
Interest in parallelism has spiked in the recent years, partly due to the realization the age of the frequency scaling as the dominant computer architecture has passed. Emerging languages such as GO and Swift actively push parallel computing, a practice previously reserved to those in high-performance computing. C++ has made large strides to welcome parallel programming, but the Standard Template Library has long lacked the parallel paradigm and can greatly benefit from its implementation.

This talk will be focused around our experience at the STE||AR group implementing and measuring the execution time and scaling of the parallel STL algorithms inside HPX. The presentation will address the benefits and the restrictions that may be present in a parallel STL.

Slides ||| PPTX 

Speakers

Friday May 15, 2015 11:00am - 11:45am
Hudson

11:00am

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

A paradigm shift that will fundamentally change C++ metaprogramming is about to begin. Be there!

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

Speakers
avatar for Louis Dionne

Louis Dionne

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


Friday May 15, 2015 11:00am - 12:30pm
Flug Auditorium

11:00am

Fun with C11 generic selection expression
One must be really brave to talk about a C-only language feature on a C++ conference, especially when the feature is considered as a parody to some well established, very successful C++ ones. Of course, I'm not that brave. This lecture will firstly introduce C11 generic selection expression to people who are not familiar with it, then primarily focus on the possible uses of such a feature in C++, see how it helps C++ generic programming and meta programming (!!), and compare it to some future C++ language additions.

Slides 

Speakers
avatar for Zhihao Yuan

Zhihao Yuan

Research Engineer, University of Virginia
Zhihao Yuan is a research developer at DePaul University. In the last several years, he participates in the C++ standardization due to personal interests, and most recently, contributed the deduction guide for std::array to C++17.


Friday May 15, 2015 11:00am - 12:30pm
Bethe

4:30pm

C++17 coroutines for app and library developers
C++17 will bring most efficient, most scalable, most open/customizable coroutines of any programming language in existence. Stackless Resumable Functions are the proposed for standardization lightweight coroutines that scale to billions of concurrent coroutines, allow to consume existing any asynchronous OS APIs / libraries with zero-overhead adapters and allow library designers go wild, invent new coroutine types and plug them into Resumable Stackless Functions machinery.

We will look at examples of tasks, goroutines, generators running on top of resumable functions. We will explore implementation details of how they actually work and look at the customization machinery that allows library designers and ordinary users to extend coroutines as needed.

Slides 

Speakers
avatar for Gor Nishanov

Gor Nishanov

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


Friday May 15, 2015 4:30pm - 6:00pm
Flug Auditorium