relajacion2424

http://CppCon.org
—
Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/cppcon/cppcon2016
—
As C++ evolves, it provides us with better and more powerful tools for optimal performance. But often, knowing the language very well is not enough. It is just as important to know your hardware. Modern computer architectures have many properties that can impact the performance of C++ code, such as cache locality, cache associativity, true and false sharing between cores, memory alignment, the branch predictor, the instruction pipeline, denormals, and SIMD. In this talk, I will give an overview over these properties, using C++ code. I will present a series of code examples, highlighting different effects, and benchmark their performance on different machines with different compilers, sometimes with surprising results. The talk will draw a picture of what every C++ developer needs to know about hardware architecture, provide guidelines on how to write modern C++ code that is cache-friendly, pipeline-friendly, and well-vectorisable, and highlight what to look for when profiling it.
—
Timur Doumler
ROLI Ltd.
JUCE Senior Software Engineer
London, UK
Timur Doumler is Senior Software Developer at London-based technology company ROLI. He is currently working on JUCE, the leading cross-platform framework for creating audio applications used by hundreds of companies in the audio industry. After five years of writing high-performance code in Fortran, C, and C++ for numerical simulations of the cosmic structure formation, Timur became committed to audio and music production software. Before joining ROLI, he worked on various projects at market-leading company Native Instruments, such as KONTAKT, the industry standard sampling platform used by the majority of music producers and composers for film score, games, and contemporary popular music. Timur holds a PhD in astrophysics and is passionate about well-written code, modern C++ techniques, science-fiction, learning languages, and progressive rock music.
—
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

http://CppCon.org
—
Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/cppcon/cppcon2016
—
Lightning Talk
—
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

http://CppCon.org
—
Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/CppCon/CppCon2017
—
If you’re looking for a fast and lightweight code editor, Visual Studio Code has you covered. Come get an overview of Visual Studio Code along with the C++ extension that enables editing, building, and debugging your C++ code across Windows, Mac, and Linux.
—
Rong Lu: Microsoft, Senior Program Manager

Rong Lu is a Program Manager in the Visual C++ team at Microsoft. She has been working on the Visual Studio team for the past 10 years since she graduated with her master degree in computer science. She is currently working on Visual Studio tools for game development, Visual C++ tools for mobile development, and the C++ experience in Visual Studio Code. She has been a frequent speaker at many conferences since 2007.
—
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

http://CppCon.org
—
Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/cppcon/cppcon2016
—
I just wanted to generate a random integer between 1 and 100 for my unit tests.

An hour later I was down the rabbit hole of the C++ ＜random＞ header wondering why it was so complicated, weren't rand() and modulo good enough and was ＜random＞ overkill, genius or both?

Several hours later I had watched STLs 2013 Going Native talk on ＜ random＞ (go watch it!), read some blogs and had even more questions: does the mt19937 generator go on the heap? Just how cheap are uniform distributions to construct? Were there even better generators out there and were they easier to use? Oh and what is entropy? How do you put it in a pool and how can it be exhausted?

The story took a few unexpected twists and turns, but in the end I got my random integers, and answers to almost all my questions which I will share. Whether ＜random＞ is genius or overkill though, you will have to decide for yourself.
—
Cheinan Marks
Spiral Genetics
As an engineer with a chemical engineering background, Cheinan is interested in practical code and wants to take the latest advances both in science and programming and use them in real life working code along with applying engineering principles to software development. Cheinan is a senior developer at Spiral Genetics, Inc. in Seattle.
—
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

http://CppCon.org
—
Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/cppcon/cppcon2016
—
Lightning Talk
—
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

http://CppCon.org
—
Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/cppcon/cppcon2016
—
GPU computing has gone mainstream. It is a dominant part of the performance landscape, providing the initial 10x performance lift to a wide variety of applications. However, programing for GPUs can be extremely challenging. C++ is rarely available in an unmodified form, and there are few portable and open source approaches available. One of the most popular platforms, CUDA, has no production quality open source implementation. As a consequence, its C++ support has lagged behind and it has been a less appealing area for researchers and others that weren’t comfortable relying on NVIDIA’s tooling.

However, today things are different. Clang is now a fully functional open-source GPU compiler. It provides a CUDA-compatible programming model and can compile most of the awesome CUDA libraries out there ranging from Thrust (the CUDA-enabled parallel algorithms library that gave rise to the new parallelism technical specification) to Eigen and TensorFlow.

In this talk we will give an overview of how LLVM and Clang support targeting C++ to GPUs, how they work to be compatible with existing CUDA code, and how you can build your code today to run on GPUs with this open source compiler.
—
Justin Lebar
Software Engineer, Google
I lead the GPU compilers team at Google. (We work on CUDA/GPU support in Clang and LLVM.)
—
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

http://CppCon.org
—
Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/cppcon/cppcon2016
—
Lightning Talk
—
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

http://CppCon.org
—
Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/cppcon/cppcon2016
—
Lightning Talk
—
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

http://www.Cppcon.org
—
Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/cppcon/cppcon2015
—
I will give a presentation on the Boost Units library.

This library implements a zero runtime facility for performing dimensional analysis checking and automatic units conversion on C++ expressions. I have found this indispensable for coding scientific programs involving a variety of complex physical units. The documentation of the Boost Units library is totally complete and accurate, but totally inpenetrable. I had to spend way too much time figuring out how to use this. By attending this meeting, you're going to avoid this pain and just get the benefit of simpler programs that contain fewer bugs.
—
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 Serialization library and a frequent contributor to the Boost developers list.
—
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

http://CppCon.org
—
Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/CppCon/CppCon2017
—
The ink on C++17 has merely dried, but the major compilers support most features already. It's high time for a reality check!

This talk is a report about the ongoing effort of porting sqlpp11 to C++17. I'll show real-world usage of the following features:

Core:
inline variables
auto non-type template parameters
[[nodiscard]]
class template deduction
constexpr if
fold expressions

Library:
string_view
optional

This talk also comes with a realization about C++11.
—
Roland Bock: PPRO Financial Ltd, Principal Software Engineer

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

Today, I am still learning and I hope to continue to do so for a very long time!

I am the author of the libraries sqlpp11 and kiss-templates.

Apart from C++ itself, I'd be particularly interested in talking about strategies for hiring C++ engineers.
—
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

http://CppCon.org
—
Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/cppcon/cppcon2016
—
In the past 6 years ChaiScript's performance has been improved by nearly 100x. This was not accomplished by adding a virtual machine or performing dynamic recompilation. Instead, these increases have been accomplished by moving to more simple, cleaner, idiomatic C++ and by following some simple rules. We will outline these concepts with examples for how they both simplified code while improving performance.
—
Jason Turner
Developer, Trainer, Speaker
Host of C++Weekly https://www.youtube.com/c/JasonTurner..., Co-host of CppCast http://cppcast.com, Co-creator and maintainer of the embedded scripting language for C++, ChaiScript http://chaiscript.com, and author and curator of the forkable coding standards document http://cppbestpractices.com. I'm available for contracting and onsite training.
—
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

http://CppCon.org
—
Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/cppcon/cppcon2016
—
You've likely used the STL before, and you are probably comfortable using std::vector some algorithms, but you may not be quite so comfortable with STL iterators. What even are "single pass writable iterators"? What does that mean to me as a user of the STL?

In this talk, we will motivate the iterator concept hierarchy as it exists in the STL today by looking at useful algorithms and how they traverse their input and output ranges. We will take these concrete examples and slowly begin to abstract, building up the STL iterator concepts, step-by-step.

After presenting the iterator concepts that exist in the STL today, we will build up to two further iterator concepts by looking at useful algorithms and then generalizing from them. First, we will motivate contiguous iterators, which have been voted into the C++17 working draft. Then, we will motivate a less-commonly known iterator concept, segmented iterators, and show how they can help us write parallel and cache-aware algorithms.

You should come away from this talk with an appreciation for generic programming, experience with the syntax in the Concepts Lite Technical Specification, and a better understanding of why iterators are fundamental to the algorithms you write every day.
—
Patrick Niedzielski
Ithaca, NY
Patrick is a Senior at Cornell University, pursuing a BA in Linguistics and Computer Science. In particular, he is interested in compiler technologies and building high-level, easy-to-use abstractions that maintain well-defined performance characteristics. With over ten years experience in C++ through open source, academic, and industry work, Patrick is enthusiastic about pushing the our understanding of C++ forward. To that end, Patrick teaches an informal C++ course that focuses on introducing students to idiomatic, modern C++ style and producing clean code. When not working at a computer, Patrick spends his time studying ancient languages and playing jazz harmonica.
—
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

http://CppCon.org
—
Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/cppcon/cppcon2016
—
Asynchronous I/O is an essential technology for increasing concurrency without introducing more threads, which carry both overhead and risks. Unfortunately, leveraging async I/O can be disruptive to careful code architecture.

This talk focuses not on the mechanics of async I/O, but rather on a library that manages async I/O with code that looks and behaves like traditional sequential code. Boost.Fiber introduces "userland threads," permitting the application coder the benefits of both async I/O and clean layers of abstraction.

This talk presents an overview of the library, discusses integration with event-driven frameworks and illustrates several useful patterns.
—

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 of writing and maintaining C++ code without Boost has become unthinkable -- even now that some of those libraries have been adopted into the C++ standard.

Nat has presented papers on coroutines and fibers to WG21, the ISO C++ committee. He has spoken on these topics at C++ Now conferences.

Nat has worked on databases, games and virtual worlds, usually on architecture and infrastructure. He has functioned as Boost evangelist within various organizations.
—
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

http://CppCon.org
—
Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/cppcon/cppcon2016
—
SIMD extensions have been a feature of choice for processor manufacturers for a couple of decades. Designed to exploit data parallelism in applications at the instruction level, these extensions still require a high level of expertise or the use of potentially fragile compiler support or vendor-specific libraries. While a large fraction of their theoretical accelerations can be obtained using such tools, exploiting such hardware becomes tedious as soon as application portability across hardware is required.

Accessing such capabilities directly from C++ code could be a major improvements in a lot of use cases. Different take on this has been proposed either by the community or as an actual standard proposal. Solutions include pragma based annotations, standard algorithms policies, full blown compiler support and libraries.
In this talk we will present one such solution - the Boost.SIMD library (currently being proposed as such) which takes a library approach to this issues.

We will go over the basic notion required to grasp SIMD programming in general. Then, we'll discuss the different existing approaches. We will describe Boost.SIMD API and API design to demonstrate how it solves issues raised by the actual idiomatic way of writting SIMD enabled code. Design issues like standard algorithm integration, memory handling and how to fill the gaps in SIMD instructions sets will be discussed. Finally, we show its performances with respect to a subset of well known benchmarks.
—
Joel Falcou
CTO, NUMSCALE
Joel Falcou is NumScale CTO. NumScale mission is to assist businesses in the exploration and subsequently the mastery of high-performance computing systems. | | He is also an assistant professor at the University Paris-Sud and researcher at the Laboratoire de Recherche d’Informatique in Orsay, France.
—
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

http://CppCon.org
—
Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/cppcon/cppcon2016
—
The BDE libraries, https://github.com/bloomberg/bde, provide a wide range of
useful functionality and also showcase the design and testing principles long
advocated by John Lakos (see Lakos '96, CppCpon 201[456]):
Fine-grained, hierarchical reusable (physical) components
Focused component purposes based on well-defined class categories.
Use of library facilities to implement effective Defensive Programming.
Ubiquitous support for a user-supplied memory--allocation mechanisms.
Design by (appropriately narrow) contracts.
After an outline of the functionality provided (e.g., date/time classes,
logging), this talk recaps the above Lakosian ideas, and shows, through BDE
documentation and code examples, how the ideas above influence the use of BDE libraries in applications.
—
Steven Breitstein
Engineer, Bloomberg LP
Professional Experience | Bloomberg, 10 years | Bell Labs, 20 years | Education | Graduate: M.I.T. | Undergraduate: City College of New York
—
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

http://CppCon.org
—
Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/cppcon/cppcon2016
—
Developing a large-scale software system in C++ requires more than just a sound understanding of the logical design issues covered in most books on C++ programming. To be successful, one also needs a grasp of physical design concepts that, while closely tied to the technical aspects of development, include a dimension with which even expert software developers may have little or no experience. In this talk we begin by briefly reviewing the basics of physical design. We then present a variety of levelization and Insulation techniques, and apply them in present-day, real-word examples to avoid cyclic, excessive, or otherwise inappropriate dependencies. Along the way, we comment on how to make the best use of what the C++ language has to offer.
—
John Lakos
Bloomberg LP
Software Infrastructure Manager
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 developed large frameworks and advanced ICCAD applications at Mentor Graphics, for which he holds multiple software patents. His academic credentials include a Ph.D. in Computer Science ('97) and an Sc.D. in Electrical Engineering ('89) from Columbia University. Dr. Lakos received his undergraduate degrees from MIT in Mathematics ('82) and Computer Science ('81). His next book, entitled "Large-Scale C++, Volume I: Process and Architecture", is anticipated in 2014.
—
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

http://CppCon.org
—
Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/cppcon/cppcon2016
—
Lightning Talk
—
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

http://CppCon.org
—
Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/cppcon/cppcon2016
—
Coroutines feel like magic. Functions that can suspend and resume in the middle of the execution without blocking a thread! We will look under the covers to see what transformations compilers perform on coroutines, what happens when a coroutine is started, suspended, resumed or cancelled. We will look at optimizations that can make a coroutine disappear into thin air.
—
Gor Nishanov
Principal Software Engineer, Microsoft
Gor Nishanov is a is a Principal Software Design Engineer on the Microsoft C++ team. He works on the 'await' feature. Prior to joining C++ team, Gor was working on distributed systems in Windows Clustering team.
—
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

http://CppCon.org
—
Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/cppcon/cppcon2016
—
What is "template normal programming"? It's template metaprogramming without so much of the "meta" part! During this talk, I promise not to mention SFINAE, or recursion, or standard type traits. We'll focus on the common scenarios "I think this code could benefit from templates, but I don't understand how to organize it;" "I can't get anything to compile without errors;" and "My coworker wrote some template code and I don't understand any of it."

In Part I of the talk, we'll start with function templates and class templates, then explain variable templates (new in C++14) and template aliases (new in C++11). We'll do a deep dive into template type deduction; then talk about full and partial specialization; and finish up with an example that motivates the final feature of C++11 template syntax, explicit instantiation.

In Part II of the talk, we'll begin by demystifying tag dispatch and traits classes; discuss situations in which you have to add disambiguating "template" or "typename" keywords (and why); and do a deep dive into the rules of what gets instantiated when and where. We'll revisit template type deduction just long enough to explain how it works for variadic templates; and explain two common template idioms — the Curiously Recurring Template Pattern and the Mixin Pattern.
Time permitting, we'll finish by exploring the big new features of templates according to the C++17 Draft Standard:
- template
- type deduction for class template constructors
- explicit deduction guides
—
Arthur O'Dwyer
Software Engineer, Mixpanel
Arthur O'Dwyer worked for many years at Green Hills Software, making the world's most optimizing C and C++ compilers. Now he works at Mixpanel in San Francisco, where he organizes a monthly C++ meetup.
—
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

http://CppCon.org
—
Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/cppcon/cppcon2016
—
Lightning Talk
—
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com