Loading…
This event has ended. View the official site or create your own event → Check it out
This event has ended. Create your own
View analytic

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

tutorial [clear filter]
Tuesday, May 16
 

4:30pm

constexpr ALL the things!
constexpr: in C++11, a curiosity; in C++14, viable for more uses; now with added power, in C++17 will it become an important tool in the programmer’s toolkit?

In this talk we will examine the possibilities and power of constexpr and explore what can (and what should) be done at compile-time with C++17. We’ll present techniques for building constexpr data structures and algorithms, and for effectively meshing compile-time and runtime computation with constexpr API constructs. We’ll also consider the opportunities for judicious use of user defined literals for expressive compile-time abstractions.

Compile-time computation offers perhaps the ultimate zero-cost abstraction, and this talk attempts to answer the question of how C++17 delivers on the promise.

Speakers
avatar for Ben Deane

Ben Deane

Principal Software Engineer, Blizzard Entertainment
Ben has been writing games for almost 20 years, and in C++ for most of that. He is currently a Principal Engineer at Blizzard Entertainment where he works on the Battle.net team. He's always looking for useful new techniques in C++, and he likes functional programming.
avatar for Jason Turner

Jason Turner

Developer, Trainer, Speaker
Host of C++Weekly https://www.youtube.com/c/JasonTurner-lefticus, 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... Read More →


Tuesday May 16, 2017 4:30pm - 6:00pm
Flug Auditorium
 
Wednesday, May 17
 

11:00am

(Ab)using C++17
C++17 is bringing with it many new small language features, and while it might not have the big features that some were hoping for, these new features can be combined and (ab)used in interesting ways. In this session we will discuss some of these new features, how they can be used and some ways they should probably not be used. We will cover fold expressions, template deduction guides, constexpr if, and returning multiple values from a function.

Speakers
avatar for Jason Turner

Jason Turner

Developer, Trainer, Speaker
Host of C++Weekly https://www.youtube.com/c/JasonTurner-lefticus, 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... Read More →


Wednesday May 17, 2017 11:00am - 12:30pm
Flug Auditorium

2:30pm

Good FIFOs Make Good Thread Neighbors
Almost every program needs parallelism to scale performance. To have useful parallelism, threads must communicate in some way. There are a few predominant ways to do this, the most ubiquitous is the first-in first-out (FIFO) queue. Have you ever thought about the micro-architectural implications of the code in your FIFO? Do certain constructs behave better or worse? We’ll look at several open source FIFO implementations, and how they behave on a set of hardware. We’ll go step by step through the code, then assembly code, and look at what happens under the hood of your processor core. Never again will you wonder about how that FIFO impacts your performance, you’ll know exactly! Come see my talk to take a tour of the most common FIFOs as they wind the load-store pathways of some common architectures.

Speakers
avatar for Jonathan Beard

Jonathan Beard

Staff Research Engineer, ARM Inc.
Jonathan Beard received a BS (Biology) and BA (International Studies) in 2005 from the Louisiana State University, MS (Bioinformatics) in 2010 from The Johns Hopkins University, and a PhD in Computer Science from Washington University in St. Louis in 2015. Jonathan served as a U... Read More →


Wednesday May 17, 2017 2:30pm - 4:00pm
Flug Auditorium
 
Thursday, May 18
 

11:00am

Parallel Programming with RaftLib: streaming/data-flow concurrency via concise C++ iostream-like operators
Almost every commodity compute device from cell phone to server has a heterogeneous multicore processor inside it. To use these complex cores, we must write code that can execute in parallel. Effective use of multicore hardware with today’s tools requires that a programmer know a lot about the hardware. This was feasible with a single core, and two cores, but how about a hundred? What happens with cores that are of different types? How about multiple memory types? How about effectively programming these systems with differing link types for each of these processor-memory combinations? This hardware complexity is not well accommodated by current software models. RaftLib aims to abstract away this complexity to make authoring performant parallel applications in C++ as simple as possible, while giving the experienced programmer the control they desire without the boiler-plate code that often comes with lower-level APIs. It utilizes the familiar semantics of stream operators to link multiple parallel actors into a parallel, streaming application. RaftLib is built as a C++ template library, enabling programmers to utilize the robust C++ standard library along with RaftLib’s parallelization framework. RaftLib enables a programmer to write C++ code that will execute in multiple processes, multiple threads, user space threads, on distributed nodes, and with optional extensions, on accelerators without learning dozens of complex interfaces. This session covers the pitfalls of programming parallel hardware, offers RaftLib as a solution, and we'll walk programmers through how to use it effectively.

Speakers
avatar for Jonathan Beard

Jonathan Beard

Staff Research Engineer, ARM Inc.
Jonathan Beard received a BS (Biology) and BA (International Studies) in 2005 from the Louisiana State University, MS (Bioinformatics) in 2010 from The Johns Hopkins University, and a PhD in Computer Science from Washington University in St. Louis in 2015. Jonathan served as a U... Read More →


Thursday May 18, 2017 11:00am - 12:30pm
Bethe

2:30pm

Implementing `variant` visitation using lambdas
The addition of `std::variant` to the upcoming C++17 standard will introduce a "type-safe sum type" to the Standard Library.
Variants model a "choice between types" - they essentially are type-safe "tagged unions".

The interface they expose, however, is often more cumbersome to use than it needs to be: defining exhaustive visitors requires the user to create a class with several `operator()` overloads, or to create a chain of `if constexpr(...)` calls. Both solutions are not very elegant.

After a brief overview of `std::variant` and its usefulness, this talk will focus on the implementation of a "lambda-based in-place visitation" approach, where the user can visit a variant by simply providing a set of lambdas on the spot. This will require implementing a way of overloading arbitrary function objects.

Recursive variant types will then be covered and the "lambda-based" visitation techniques will be applied to them. This will require implementing the "Y combinator" higher-order function to achieve zero-runtime-overhead lambda recursion.

This talk is intended for developers familiar with C++11 and C++14 core language features (lambdas, variadic templates, `auto`, etc...). Prior knowledge of `std::variant` or sum types is not required.

Speakers
avatar for Vittorio Romeo

Vittorio Romeo

Software Engineer, Bloomberg LP
Vittorio Romeo is an Italian 22 year old Software Engineer at Bloomberg LP. He completed his Bachelor's degree in Computer Science at "Università degli Studi di Messina". | | He began programming at a very young age and is now a C++ enthusiast. While following the evolution... Read More →


Thursday May 18, 2017 2:30pm - 4:00pm
Bethe

4:30pm

Towards Painless Testing
In this tutorial we will be following the teachings of the Beyonce rule - "If you liked it then you should have put a test on it".
We will go above and beyond to make testing as painless as possible with modern C++. If you don't like writing Google Mocks
by hand then this tutorial is for you! As it will be shown how to eliminate this daunting task from your daily routine.
Additionally, it will be presented how to write a C++14 automatic mocks injector to make your testing life easier!
Its final focus will be on increasing your productivity with TDD (Test Driven Development) and BDD (Behavior Driven Development)
and to round it up, a vision of how testing may look like in C++20 and beyond will be discussed.

Speakers
avatar for Kris Jusiak

Kris Jusiak

Senior Software Engineer, Quantlab Financial
Kris is a Software Engineer focusing on modern C++ development where performance (including compilation times) and quality matters. He has been crafting modern C++ in telecommunications, games and recently finance industries. Kris is an author of [Boost].DI, [Boost].SML and GUnit... Read More →


Thursday May 18, 2017 4:30pm - 6:00pm
Hudson Commons
 
Saturday, May 20
 

8:45am

clang-useful: Building useful tools with LLVM and clang for fun and profit
The talk will consist of two parts. The first will be a general overview of the LLVM and clang library infrastructure available for creating custom tools such as static analyzers or source-to-source transformation tools. I will explain the ecosystem of the LLVM and clang tooling environment and outline options, tradeoffs and examples of the different ways of creating a tool (e.g. the difference between creating a plugin vs. a LibTooling executable). I will then go further in depth about how clang represents C++ source code by means of an AST and ways of traversing the AST to look for certain points of interest, e.g. old-style for loops that could be converted to range-based loops, or braces that are indented in Allman instead of One-True-Brace-Style, which could be useful for any company with a style guide it wants to enforce at compile-time rather than on paper or in code-reviews.

For the second part, I will then branch out into the two common tasks one might want to perform with a custom-built tool: emitting warnings or errors (for static analysis), and transforming and emitting new code (source-to-source transformations, such as clang-tidy). For each use-case, I will walk through real code that shows how one might approach a simple task in each category.

At the end of the talk, I expect listeners to have a basic understanding of the LLVM/clang tooling environment and AST representation. However, most importantly, I expect people to take away knowledge they can take home or to their office and immediately build tools in no time at all that *genuinely* improve their workflow and productivity. This is not a "give a man a fish" talk. This is a "teach a man to fish" talk.

Speakers
avatar for Peter Goldsborough

Peter Goldsborough

Intern, Facebook
I'm Peter and technically a second year CS student at TU Munich. Practically, I'm a first year student who decided to do a gap year and join the workforce. Since last August I've been doing engineering internships: first Google, then Bloomberg, now Facebook. I currently physicall... Read More →


Saturday May 20, 2017 8:45am - 10:15am
Flug Auditorium

8:45am

Type-safe Programming
C++ provides a really advanced type system. A prime example of its application is std::chrono: It uses the type system to create different types for different units and prevent programmer errors.

But the same principle can be applied to your everyday code - this talk is going to show you how. I'll present simple techniques to leverage the C++ type system to detect and prevent possible bugs at compile-time. We'll start with the bare minimum - minimize implicit conversions, and then quickly go to more advanced things like using types to express preconditions or general guidelines about type-safe class design.

This talk is in part based on ideas and concepts implemented in my type_safe library (http://type_safe.foonathan.net/).

Speakers
avatar for Jonathan Müller

Jonathan Müller

Student, RWTH Aachen University
Jonathan is a CS student passionate about C++. In his spare time he writes libraries like foonathan/memory which provides memory allocator implementations. He is also working on standardese which is a documentation generator specifically designed for C++. Jonathan tweets at @foon... Read More →


Saturday May 20, 2017 8:45am - 10:15am
Hudson Commons