bailar24

http://CppCon.org
—
Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/CppCon/CppCon2017
—
C++ Coroutines come naked. Just the language feature, no library support apart from a few traits that allow developing coroutine adaptors.

In this session we will start with just a compiler that implements a coroutine TS and a reference networking TS implementation and through (mostly) live coding together we will develop a cool, efficient and beautiful async networking app.
—
Gor Nishanov: Principal Software Engineer, Microsoft

Gor Nishanov is a Principal Software Design Engineer on the Microsoft C++ team. He works on design and standardization of C++ Coroutines, and on asynchronous programming models. Prior to joining C++ team, Gor was working on distributed systems in Windows Clustering team.
—
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/CppCon2018
—
How can we communicate with other developers about the safety of our C++ code against the hazards of concurrency? Terms like "thread-safe" don't always have a clear meaning, and more precise terms like "data race" and "race condition" often operate at the wrong level of abstraction. In order to communicate effectively about these issues, we need straightforward ways to talk about the safety requirements that APIs impose, and what goes wrong if you violate them.

In this talk, I will present the simple yet precise vocabulary we use for talking about these issues at Google: an "API race" happens when two operations access the same object concurrently, in violation of its contract. For most C++ types, that contract can be classified as "thread-safe" or "thread-compatible" depending on what combinations of operations can cause an API race (the remainder are called "thread-unsafe"), and that two-word classification usually tells you everything you need to know to avoid API races on the object. This is significant because if you can avoid API races, you can avoid not only all data races but also many race conditions.
—
Geoffrey Romer, Google
Software Engineer

I'm a Staff Software Engineer on the C++ Library Team at Google, and the lead author of Google's C++ concurrent programming guide. My work focuses on improving the C++ programming experience at Google and beyond, which has led me to focus on problem areas such as concurrent programming, error handling, hashing, and memory management. I'm a co-owner of Google's C++ style guide, and have been active on the C++ Standards committee since 2014, including a stint as editor of the Library Fundamentals TS. Currently, I'm leading Google's efforts to adopt coroutines in C++, and working on API designs for mitigating speculation attacks such as Spectre Variant 1.
—
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/CppCon2018
—
Slides Now Available at : https://nxxm.github.io/cppcon2018/
The elegance how a C++17 application can bind to HTML5 will be shown, while running a C++17 data-model on WebAssembly in the server and the browser.
While we will look at the useful libraries, tips and techniques C++17 offers in this context. We will weigh the gains and the pains of modern C++ applied to the HTML5 user experience.

The effective impact on maintainability, performance & lightness of web applications will be measured in comparison to typical web development techniques.
—
Damien Buhl, nxxm
Software Developer

Damien is an enthusiast software developer with a strong focus on C++ & Javascript. Leading development & product releases with tight schedules in an 100 years old IoT and Building Automation company in beautiful Basel, Switzerland. Open Source contributor of Boost.Fusion and creator of nxxm.
—
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/CppCon2018
—
We often write programs in such a way as to make them run fast. We want good average speed, high throughput, and we tend to be happy when benchmarks show that our peak running speed is better than expected.

However, it's sometimes useful to write programs where we want to make the worst-case scenario faster, or make it run at predictable speed, or even reduce variations in execution speed. Instead of concentrating our efforts on making the best or the average speed better, we sometimes need to make the worst case speed "less bad".

C++ is a wonderful language for such situations. C++ gives us a lot of control over what's going on, and we can use this control to our advantage.

The aim of this talk is to discuss techniques to make the execution speed of programs more predictable, and to guide the compiler towards generating code where worst-case execution speed respects some constraints. It will probably most interesting to intermediate audiences who are curious about how to address such issues, or who wonder why it is sometimes important to be pessimistic and worry about those times when program execution takes the slow path.
—
Patrice Roy, Université de Sherbrooke
Professeur

Patrice Roy has been playing with C++, either professionally, for pleasure or (most of the time) both for over 20 years. After a few years doing R&D and working on military flight simulators, he moved on to academics and has been teaching computer science since 1998. Since 2005, he’s been involved more specifically in helping graduate students and professionals from the fields of real-time systems and game programming develop the skills they need to face today’s challenges. The rapid evolution of C++ in recent years has made his job even more enjoyable. He’s been a participating member in the ISO C++ Standards Committee since late 2014 and has been involved with the ISO Programming Language Vulnerabilities Committee since late 2015. He has five kids, and his wife ensures their house is home to a continuously changing number of cats, dogs and other animals.
—
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

http://CppCon.org
—
Discussion & Comments: https://www.reddit.com/r/cpp/
—
Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/CppCon/CppCon2019
—
Reading structured data from a file or network stream remains cumbersome and error-prone in C++, especially when data validation is required. Existing approaches require too much boilerplate, aren't always portable, and may be restricted to specific data sources. Despite these limitations, there have been few alternatives in the past.

This talk introduces blobify, an experimental serialization framework for C++17 designed to convert user-defined structs to binary data blobs and vice-versa. Contrary to similar frameworks, blobify largely automates the process, and it includes an embedded domain specific language to handle data validation.

I will describe blobify's API design and usage, explain how it works under the hood, and provide an outlook at what the Reflection TS has in store for future improvements.

Link to the library on GitHub: https://github.com/neobrain/blobify
—
Tony Wasserka
Consultant
Berlin, Germany

Low-level anything: Tony is a consultant and long-term C++ enthusiast who has worked on the console emulator projects Dolphin (GameCube/Wii), PPSSPP (PSP), and Mikage (3DS) since 2010. More recently, he has worked on Vulkan graphics drivers for PowerVR graphics processors. His main interest is exploring C++'s zero-cost abstraction capabilities and applying them to create better software for resource-constrained environments.
—
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/CppCon2018
—
Software with very complex business logic, such as games, CAD systems, and enterprise systems, often needs to compose and modify objects at runtime - for example to add or override a method in an existing object. Standard C++ has rigid types which are defined at compile time and make this hard. On the other hand languages with dynamic types like lua, Python, and JavaScript make this very easy. Therefore, to keep the code readable and maintainable, and accomplish complex business logic requirements, many projects use such languages alongside C++. Some drawbacks of this approach include the added complexity in a language binding layer, the performance loss from using an interpreted language, and the inevitable code duplication for many small utility functionalities.

DynaMix is a library which attempts to remove, or at least greatly reduce, the need for a separate scripting language by allowing the users to compose and modify polymorphic objects at runtime in C++. This talk will elaborate on this problem and introduce the library and its key features to potential users or people who might benefit form the approach with an annotated example and a small demo.
—
Borislav Stanimirov, Bulgaria

Borislav has been a C++ programmer for 15 years. In the past 11 he has been programming video games. He has worked on C++ software for all kinds of platforms: desktops, mobile devices, servers, and embedded. His main interests are software architecture and design, and programming languages.
—
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/CppCon2018
—
Ever wanted to modify some value or execute some statement while your C++ program is running just to test something out - not trivial or possible with a debugger? Scripting languages have a REPL (Read-Eval-Print-Loop). The closest thing C++ has is cling (developed by researchers at CERN) but it is built on top of LLVM and is very cumbersome to set up and integrate.

In this presentation we will go through the inner-workings of a project showcasing an innovative approach to doing runtime C++ compilation in a platform and compiler agnostic way which can be easily embedded. We will see how to use it, how it works and how to modify and integrate it into any application and workflow.

WARNING: 2 live demos !!!
—
Viktor Kirilov
Bulgaria

With 4 years of professional experience with C++ in the games and VFX industries, Viktor currently spends his time writing open source software (since 01.01.2016). He is the author of doctest - "The fastest feature-rich C++11 single-header testing framework".

His interests are the making of games and game engines, high performance code, data oriented design, blockchains, optimizing workflows and incorporating good practices in the software development process such as testing and the use of modern tools like static analysis or instrumentation.

Viktor is from Sofia, Bulgaria and his profession is his hobby.
—
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

http://CppCon.org
—
Discussion & Comments: https://www.reddit.com/r/cpp/
—
Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/CppCon/CppCon2019
—
Starting with C++11, new features were introduced into the language and Standard Library that were immediately useful for quantitative developers in financial trading and risk management, yet not very much about these applications seems to have been presented at C++ conferences. Even recently published textbooks for C++ courses in finance still lag in covering these powerful new tools. Welcome additions such as distributional random number generation, task-based concurrency, and lambda expressions provide express lanes to coding necessary components of financial libraries that were once far more time consuming and less reliable to implement. Furthermore, beginning with C++17, parallel STL algorithms have become available to speed up routine computations, typically by simply adding an additional parameter.

In addition, Statistical Distributions, Circular Buffers for time series data, MultiArrays for option pricing lattices, and Quadrature for numerical integration are well-designed Boost libraries that add to an increasingly robust arsenal at the quant developer’s disposal.

The presentation will close with a review of how C++ is perceived in quantitative applications work – not always positive unfortunately – and proposals for overcoming these challenges, specifically by emphasizing and building on the progress made since C++11, and further modernizing math features in Boost.

Quantitative developers in both finance and other technical fields will see how to quickly leverage modern and powerful mathematical tools in C++ with minimal overhead to get on with the job quickly. Members of the Committee and larger C++ community should come away with a clearer view of quantitative developers’ demands for the language, and ideas for growing C++’s presence in the rapidly growing domain of computational finance in particular, and mathematical programming in general.
—
Daniel Hanson
University of Washington, Applied Mathematics
Lecturer

Daniel Hanson spent 24 years in quantitative development in finance, primarily with C++ implementation of option pricing and portfolio risk models, and related library development. He now holds a full-time lecturer position in the Department of Applied Mathematics at the University of Washington, teaching quantitative development courses in the Computational Finance & Risk Management (CFRM) MSc program. This includes intermediate and advanced classes in computational C++, and mentoring students in Google Summer of Code projects involving implementation of mathematical models in C++ and R.
—
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

http://CppCon.org
—
Discussion & Comments: https://www.reddit.com/r/cpp/
—
Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/CppCon/CppCon2019
—
C++20 comes with some big new language features: modules, coroutines, concepts, spaceship, and many new libraries. But apart from all those, C++20 also offers many small language improvements, making C++ more powerful and expressive, but also safer and more consistent.

This talk is an overview over all those smaller additions to the core language that will make your life easier. We will discuss much-needed improvements to existing facilities such as lambdas, CTAD, structured bindings, and initialisation, as well as brand-new language utilities that you may not yet have heard about!
—
Timur Doumler
Timur Doumler is a C++ developer specialising in audio and music technology, active member of the ISO C++ committee, and part of the includecpp.org team. He is passionate about building communities, clean code, good tools, and the evolution of C++.
—
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/CppCon2018
—
Abstract: This talk explains the relationship between good code and a good human interface (graphical or otherwise). Human interface semantics are tightly coupled with code semantics and improving how we reason about code can have a direct on positive impact on the human interface behavior of the system. Part of my “Better Code” series of talks, the goal is “Don’t Lie.”
—
Sean Parent, Adobe
Principal Scientist

Sean Parent is a principal scientist and software architect for Adobe’s 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 to work on mobile and web technology. From 1988 through 1993 Sean worked at Apple, where he was part of the system software team that developed the technologies allowing Apple’s successful transition to PowerPC.
—
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/CppCon2018
—
Macros, templates, compile-time evaluation and code generation, reflection and metaclasses – C++ tends to hide the final code passed to the compiler under the tons of various names and aliases. Add here the preprocessor that shadows the actual running curve of your program with dozens of alternatives mixed in a non-trivial way. While this allows to avoid boilerplate code and reduce copy-paste and other errors, such an approach demands better tooling support to make the debugging process easier.

To find an error in such a code, one has to continuously read-fix-run it and compare the results with some etalon, or to debug in order to find actual substitutions. But should you really wait until your code is run or even compiled to debug it? Or how to deal with the situations when the code can’t be run on the local machine? A text editor with code completion won’t help, while a smart IDE that “gets” your code can do a better job.

In this talk we’ll see interesting approaches to solving cases like macro and typedef ‘debug’, understanding types when auto/decltype hide them, dealing with different code branches depending on the preprocessor’s pass-through, and other ideas. Some suggestions are already implemented as ready-to-use features in CLion and ReSharper C++, tools for C++ from JetBrains (that means I can show it in action), others are planned for the future. The aim of this talk is to share the workflows supported by the tools that can help C++ developers create better modern C++ code.
—
Anastasiia Kazakova, JetBrains
PMM

As a C and C++ software developer, Anastasia Kazakova created real-time *nix-based systems and pushed them to production for 8 years. She has a passion for networking algorithms and embedded programming and believes in good tooling. With all her love for C++, she is now the Product Marketing Manager on the JetBrains CLion team. Besides, Anastasia runs a C++ user group in Saint-Petersburg, Russia ( https://www.meetup.com/St-Petersburg-...).
—
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 feature set for the C++17 release is set, and the release of the standard is just around the corner. In this session, we'll discuss all the new C++ features in C++17 and how they'll change the way we write C++ software. We'll explore the new standard in breath, not width, covering a cornucopia of core language and library features and fixes:

Language Changes (part 1):
Structured bindings
Selection statements with initializers
Compile-time conditional statments
Fold expressions
Class template deduction
auto non-type template parameters
inline variables
constexpr lambdas
Unary static_assert
Guaranteed copy elision
Nested namespace definitions
Preprocessor predicate for header testing

Library Changes (part 2):
string_view
optional
variant
any
Parallel algorithms
Filesystem support
Polymorphic allocators and memory resources
Aligned new
Improved insertion and splicing for associative containers
Math special functions
Variable templates for metafunctions
Boolean logic metafunctions
—
Bryce Adelstein Lelbach: NVIDIA, Senior Software Engineer

Bryce Adelstein Lelbach is a senior software engineer on the CUDA driver team at NVIDIA. Bryce is passionate about parallel programming. He maintains Thrust, a C++ parallel algorithms library, and he 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 for Computation and Technology, and three years at Lawrence Berkeley National Laboratory (a US Department of Energy research facility) developing and analyzing new parallel programming models for exascale and post-Moore architectures. He also helped start the LLVMLinux initiative, and has occasionally contributed to the Boost C++ libraries. Bryce is an organizer for the C++Now and CppCon conferences as well as the Bay Area C++ user group, and he is passionate about C++ community development. He is a member of the ISO C++ standard committee, and worked on the C++17 parallel algorithms.
—
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/CppCon2018
—
If you’re writing modern C++ code, then it’s likely that you are using exceptions—whether you’re throwing them yourself or just using library code that might throw (e.g., std::vector). Have you ever stopped to think about how exceptions work under the hood? What actually happens at runtime when you throw an exception? How is the right catch statement found?

In this session, we’ll explore how C++ exceptions actually work in the Visual C++ implementation on Windows. This session will discuss:

* A very, very brief overview of how exceptions work in the C++ language
* The code and data structures the Visual C++ compiler generates to facilitate proper stack unwinding
* Exactly what happens when an exception is thrown, how the right catch statement is found, and how the stack is unwound
* Structured Exception Handling (SEH), the Windows OS feature atop which C++ exceptions are built
* How the Visual C++ runtime library interacts with the OS during stack unwinding
* Interoperation with non-C++ exceptions, like hardware exceptions
* How termination handling works when no matching catch statement is found or when a noexcept boundary is reached
* How things differ on different architectures (x86 is very different from x64 and ARM!)

This information can be very useful when debugging tricky problems—especially during postmortem debugging when you’re trying to figure out what went wrong before a program crashed—and we’ll highlight particular pieces of information that are most useful.
—
James McNellis, Microsoft Corporation
Principal Software Engineer

James McNellis is a Principal Software Engineer at Microsoft where he works on the Time Travel Debugging (TTD) reverse debugging toolkit. Prior to joining the Windows Debuggers team in 2016, he worked on the Visual C++ team and was responsible for the Microsoft C Runtime (CRT) and C Standard Library implementation. Passionate about all things related to C++, he is a frequent speaker at C++ conferences around the world and is a former top contributor on StackOverflow.
—
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/CppCon2018
—
Static analysis tools can aid programmers by reporting potential programming mistakes prior to the execution of a program. Funqual is a static analysis tool that reads C++17 code ”in the wild” and checks that the function call graph follows a set of rules which can be defined by the user. This sort of analysis can help the programmer to avoid errors such as accidentally calling blocking functions in time-sensitive contexts or accidentally allocating memory in heap-sensitive environments. To accomplish this, we create a type system whereby functions can be given user-defined type qualifiers and where users can define their own restrictions on the call tree based on these type qualifiers. We demonstrate that this tool, when used with hand-crafted rules, can catch certain types of errors which commonly occur in the wild. We claim that this tool can be used in a production setting to catch certain kinds of errors in code before that code is even run.
—
Andrew Nelson, Arista Networks
Software Engineer

Andrew is passionate about creating tools and methodologies that enable everyone to write high quality software. He recently completed a masters degree at Cal Poly SLO where his area of research involved static analysis. Today he works at Arista Networks on tools that make developers more productive. Andrew spends a lot of his free time teaching Computer Science to high school students (he mentors a highschool robotics team and tutors students in AP Computer Science) and has seen a lot of interesting bugs while doing so!
—
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/CppCon2018
—
At some point in your career, you will need to teach someone something about C++. You might not be a lecturer or a trainer, but you could be helping a colleague with a problem that they're solving, presenting at a lunch-time session, or even at a conference! Perhaps you're someone who is helping to write your company's style guide or "Intro to Our Repo" manual. Correctly teaching C++ is a tough endeavour. C++ is often taught incorrectly at the university level, via online resources, and in books. Many resources are still outdated or refuse to change with the paradigm shift that the C++ community has been undergoing over the past two decades.

We should seek to convey correct information and provide resources that are factual. We should make learning C++ an enjoyable experience, and that stems from the way in which we teach it.

This talk digs into how we can achieve some of this, but it by no means provides all the answers, and may lead to more questions.
—
Christopher Di Bella, Codeplay Software
Staff Software Engineer, ComputeCpp Runtime

Christopher Di Bella is a Staff Software Engineer for Codeplay’s ComputeCpp Runtime Technology. He is a strong proponent for having the Concepts TS and the Ranges TS in C++20. Chris spends his days working on ComputeCpp, Codeplay’s implementation of SYCL; the Khronos implementation for the Parallel STL (using SYCL); and researching Parallel Ranges, which is an attempt to bring the aforementioned Ranges TS together with the parallel algorithms. He was previously a software developer for Nasdaq, and a tutor for UNSW Australia’s COMP6771 Advanced C++ Programming course in Sydney, Australia. In his spare time, Chris enjoys snowboarding, playing games, and watching films.
—
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/CppCon2018
—
The C++ Modules-TS is progressing through standardization as
experience is gained through implementations, and I am implementing it
in the GNU G++ compiler. I will cover:

* background of the modules-TS
* changes since the TS was first published
* build integration possibilities
* implementation details
* predictions about releases, maybe
—
Nathan Sidwell, Software Engineer
Facebook
Nathan is a developer of the GNU Compiler Collection, particularly the C++ Front End. His current major project is implementing and influencing the modules TS.
—
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com