CppCon 2018

Ever thinking of creating your own specific-purpose programming language? Or maybe improving programming experience by adding a language feature in existing language? This talk presents about Embedded Domain-Specific Language (EDSL) from basic concepts and technique to build it using C++.

EDSL is a powerful technique in integrating a custom libraries or frameworks in users’ codes. EDSL can improve user’s experience in using libraries by reducing boilerplate codes and providing more readable and straightforward codes. Some success stories are: Boost.Spirit, Boost.Proto.

Although Boost.Proto provides tool to build EDSL in C++, this talk presents building EDSL from the ground up utilizing operator overloading, template metaprogramming, and macro. We use operator overloading and template metaprogramming to build a simple expression tree for our EDSL.

This talk provides an example of developing an “asynchronous block” within C++ codes to be used in Tizen native application development. The “asynchronous block” has similar purpose with C++11 std::async but targeting a different API and mimicking the structure of try-catch block.

In this talk we will share the joy of seeing ordinary C++ concurrent code, doing ordinary concurrent things in 100000 concurrent threads. I’ll analyze how the code is behaving and point out what is similar and different about the execution of that code at this scale. This talk is the code-heavy continuation of last year’s English-heavy “Designing C++ Hardware” about the Volta architecture.

Featuring:

• Multiple compilers.
• Godbolting.
• C++20 concurrency predictions.
• Live demo (attempt).

Data de-serialization is a surprisingly common task in game console emulation (kernel interfaces, driver communication, and file IO), and to address it we usually use repetitive boilerplate code that is often nothing but error-prone and unmaintainable. How can modern C++ help?

We take a look at the interprocess communication subsystem of the Nintendo 3DS and see how generative programming tools (variadic templates, function reflection, metaprogramming) and a declarative approach give us wins in performance, maintainability, and correctness.

The takeaway of this session is a glimpse at generators, declarative interfaces, and how to use them to solve serialization-like problems with minimal effort and maximum reusability.

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.

C++ major benefit is its deterministic lifetime model of variables and values. This lead to the RAII (resource-acquisition is initialization) idiom that is essential for resource safety and less leakage. Some standard library classes already implement RAII for specific cases, such as heap-allocated pointers, mutex locking or file-I/O.

While some "mis"-uses of unique_ptr are recommended as a general RAII wrapper, those uses sometimes fail to be general enough. This lead Andrew Sandoval to specify a unique resource wrapper for the standard libary in 2013 (N3677). This talk tells the story how the author helped shepherding that mechanism through at least 12 revisions to make it into the standard library, which might be achieved while CPPCon runs, or not yet (hopes are high).

Implementing a RAII wrapper seems trivial, just implement a constructor and destructor, but doing so in generic ways is hard and tricky. Even with simple DIY solutions, interesting effects lurk and can lead to surprises also when using the generic solutions potentially provided by C++20.

The Boost Community invites anyone interest to join. Registration is here: https://cppcon2018.eventbrite.com/

This session will be focusing on my work specifically over the past two years rebuilding the software development infrastructure at my current company.  The session will explain my journey to, and detail on our current systems which leverage many understood best practices and up-to-date technologies to streamline our development processes.

This work is interesting and applicable to any developer not working with an already established, well maintained infrastructure.  This effectively covers many small and medium size companies whose developers may be following the progress of C++ but feel stuck, unsure how to deploy modern tooling into their development cycles.  There is a real need especially outside of the direct software industries for developers and teams to understand that they can, and should use modern best practices.

Throughout the session attendees will be presented with what has been my approach to solving infrastructure problems.  The session will be primarily highlighting my use, and integration of five specific tools available to our industry.  I will be discussing my journey chronologically in deploying Jenkins, Git (GitLab), updating our CMake infrastructure, and ultimately using Docker to help synchronize our builds across multiple platforms.  As part of the discussion I will also be highlighting my use of more standard industry tools such as Clang-Tidy, Clang-Format, compiling with both Clang and GCC, exercising sanitizers from each compiler, recording code coverage with KCov, and how it all ties together with the build, revision control, and bug reporting services.

Although expression templates have been around for many years and are a great example of compile-time code generation, they have typically been limited to relatively short expressions who's grammar can be expressed as a tree. What do you do when you want to express something more like an assembly-language program, with loops (cycles) in it? This was the problem that I encountered when trying to identify certain loop patterns in an LLVM compiler back end. The LLVM infrastructure provides a pattern matching library, but it has some limitations -- most notably the inability to express cycles in the code it matches.

Taking the idea of expression templates and kicking it up a notch, I created a library that allows an input pattern to be expressed directly in C++ using a syntax that resembles assembly language then generate, at compile time, an actual pattern-matching subroutine customized for that pattern. In the process, I deepened my knowledge of constexpr expressions, and built an interesting infrastructure that I will now share with you.

This talk is for the advanced C++ programmer. An understanding of templates, type traits, and basic metaprogramming is assumed. No prior knowledge of LLVM or compilers is required, though compiler back-end implementers will find this talk especially interesting.

Clang-tidy is the go to assistant for most C++ programmers looking to improve their code. If you set out to modernize your aging code base and find hidden bugs along the way, clang-tidy is your friend. Last year, we brought all the clang-tidy magic to Visual Studio C++ developers with a Visual Studio extension called “Clang Power Tools”. After successful usage within our team, we decided to open-source the project and make Clang Power Tools available for free in the Visual Studio Marketplace. This helped tens of thousands of developers leverage its powers to improve their projects, regardless of their compiler of choice for building their applications.
Clang-tidy comes packed with over 250 built-in checks for best practice, potential risks and static analysis. Most of them are extremely valuable in real world code, but we found several cases where we needed to run specific checks for our project. This talk will share some of the things we learned while developing these tools and using them at scale on our projects and within the codebases of our community users.

http://clangpowertools.com
https://github.com/Caphyon/clang-power-tools

This is an experience report with talks, demos, and Q&A by the authors of the Clang-based implementation of Herb Sutter’s Lifetime safety profile for the C++ Core Guidelines, available online at cppx.godbolt.org.

We will cover the kinds of diagnoses supported by the checker and how they are implemented using Clang’s type trees and control flow graphs, including use-after-invalidation (dangling) and null-dereference compile-time diagnostics for pointers, iterators, views, and more. We will also summarize early experience with performance against real-world code bases, including compile time performance and initial analysis results from compiling LLVM sources with the checker.

Also, if you try the online compiler and have questions about why any examples are flagged or not flagged, you can bring them and ask the implementers!

Traditionally it's been hard or downright impossible to have C++ on a GPU: Graphics Shaders are mainly done in GLSL/HLSL (C-like languages) and Compute Shaders only recently run it via CUDA/LLVM complex toolchains. This is not always desirable or available - mobile phones for ex. Turns out code can compile both as valid C++ and shader language with a bit of library writing effort. All you mostly need is equivalent 2D/3D/4D vector and matrix types.

What's the catch then? Swizzling! The shader vector allows addressing of its components both as [0], [1], [2] etc but also as .x, .y, .xyz, .zyx, .xxx and all possible combinations. The talk details how this can be achieved in modern C++, clean and in a generic way, without preprocessor tricks, and overcome language obstacles like template argument deduction with implicit conversions. After all the effort it's possible to prototype complex procedural effects at an interactive rate with full CPU-side debugging. Of course, a dedicated GPU will very quickly outpace this but loses the debugging, and some devices might not always produce correct results due to driver bugs.

As takeaway and showcase of what can be achieved with the C++ techniques presented I'll introduce Signed Distance Field functions modeling and some shaders that use it: Procedural Generated Planet, Volumetric Clouds simulation and some fun experiments: a Vinyl Turntable and an Egg On Bicycle!