paletatiptip

http://CppCon.org
—
Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/cppcon/cppcon2016
—
What are variants, why are they important, and how I use them? Once available to a developer, variants become one of the most commonly used tools in everyday programming. This talk will explore the venerable Boost.Variant library, discuss the improvements made by C++17’s std::variant＜＞, and close with a discussion of the exciting new language-based variant and pattern matching papers (proposed for C++20). This talk aims to be of practical utility in variant library usage and informative as to where things are heading.
—
David Sankel
Bloomberg
New York, New York
David Sankel is a professional software developer/architect based in the USA and an active member of the C++ Standardization Committee. His prolific software developments have included CAD/CAM, computer graphics, visual programming languages, web applications, computer vision, and cryptography. He is a frequent speaker at the C++Now conferences and is especially well known for his advanced functional programming in C++ talks. David’s interests include large-scale development, dependently typed languages, semantic domains, EDSLs, and functional reactive programming. David's current research interests include dependently typed languages, semantic domains, EDSLs, and functional reactive programming. He currently works for Bloomberg.
—
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
—
When innovation-hungry programmers discovered by accident that C++ allows us to calculate and transform programs at compile time, an humongous hype was triggered: gigantic research projects were launched to develop self-optimizing software. Unfortunately, such software also had gigantic compile times of up to several days on parallel machines. And the syntax of template meta-programming can drive the toughest geeks into insanity. Despite this disillusion, the compiler support improved over the years and constexpr brought us a much simpler syntax.

In this light we like to ask the questions: What can,
should, and must we compute at compile time? Which new opportunities offer constexpr and their extension in C++14? What have to be done in the classical manner still? We will discover the different techniques of meta-programming with examples of simple examples, type information, expression templates and meta-tuning. Without becoming unbearably theoretical, we will show the equivalence of constexpr in C++11 and C++14 and their Turing completeness.
—
Peter Gottschling
CEO, SimuNova
Peter Gottschling is founder of SimuNova, a company that works on developing the Matrix Template Library (MTL4) and offers C++ training. He is a member of the ISO C++ standards committee, vice-chair of Germany s programming language standards committee, and founder of the C++ User Group in Dresden. He earned his Ph.D. in computer science at Technische Universitat Dresden in 2002.
—
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
—
Writing correct C++ is hard. Period. Full stop. Even if a small change to a simple 2,000-line program compiles, has tests, and passes the tests, the code might still be broken. When the code spans hundreds of thousands of files across many different projects, making sure your change is safe is orders of magnitude harder. This talk is about all of the things that make that problem manageable for a Facebook engineer to tackle.
—
Mark Isaacson
Facebook
Software Engineer
Mark Isaacson is a Software Engineer at Facebook, where he works on improving the developer experience for all C++ programmers at Facebook. Mark is the author of the tech blog "Modern Maintainable Code" that tries to educate folks about properties of maintainable code and effective program design. Mark has a background in teaching and has been giving tech talks for several years now, most of which can be found on his blog. Website: http://modernmaintainablecode.com
—
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
—
There has been an overwhelming amount of tension in the programming world over the last year due to something that has become an expletive, a cursed and despised term, both obscene and profane: **undefined behavior**. All too often, this issue and the discussions surrounding it descend into unproductive territory without actually resolving anything.

In this talk, I'm going to try something very bold. I will try to utterly and completely do away with the use of the term "undefined behavior" in these discussions. And I will unquestionably fail. But in the process of failing, I will outline a framework for understanding the actual root issues that the software industry faces here, and try to give constructive and clear paths forward, both for programmers and the programming language.

And, with luck, I will avoid being joined on stage by any unruly nasal demons.
—
Chandler Carruth
Google
C++ Lead
San Francisco Bay Area
Chandler Carruth leads the Clang team at Google, building better diagnostics, tools, and more. Previously, he worked on several pieces of Google’s distributed build system. He makes guest appearances helping to maintain a few core C++ libraries across Google’s codebase, and is active in the LLVM and Clang open source communities. He received his M.S. and B.S. in Computer Science from Wake Forest University, but disavows all knowledge of the contents of his Master’s thesis. He is regularly found drinking Cherry Coke Zero in the daytime and pontificating over a single malt scotch in the evening.
—
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 the most powerful algorithm in the STL? In the world? There are many cases to be made. But this talk explores what I think is a pretty good candidate, which C++ calls std::accumulate(). Tucked away in ＜numeric＞, perhaps relatively unregarded when compared with workhorses like std::find_if() and std::partition(); nevertheless, std::accumulate() is in some sense the ur-algorithm on sequences.

Let’s explore the result of looking at code through an accumulate-shaped lens, how tweaking the algorithm for better composability can unlock many more uses, and how it can be further genericized with applications to parallelism, tree structures, and heterogeneous sequences.

std::accumulate(): it’s not just for adding things up!
—
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.
—
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
—
There has always been great interest in imperative compile-time control flow: as an example, consider all the existing `static_if` proposals and the recently accepted `constexpr_if` construct for C++17.

What if you were told that it is actually possible to implement imperative control flow in C++14?

In this tutorial, the implementation and design of a compile-time `static_if` branching construct and of a compile-time `static_for` iteration construct will be shown and analyzed. These constructs will then be compared to traditional solutions and upcoming C++17 features, examining advantages and drawbacks.
—
Vittorio Romeo
Bloomberg LP
Software Engineer
London, UK
Vittorio Romeo is an Italian 21 year old Computer Science student at "Università degli Studi di Messina". He began programming at a very young age and is now a C++ enthusiast. While following the evolution of the C++ standard and embracing the newest features, he worked on several open-source projects, including modern general-purpose libraries and free cross-platform indie games. Vittorio is an active member of the C++ community: he participated as a speaker at CppCon 2014/2015, ++it Florence 2015 and at his local Linux Day 2013/2014 events, as a Student/Volunteer at C++Now 2015, and as part of Meeting C++ 2015's student program. He currently maintains a YouTube channel featuring well-received modern C++11 and C++14 tutorials. When he's not writing code, Vittorio enjoys weightlifting and fitness-related activities, competitive/challenging computer gaming and good scifi movies/TV-series.
—
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
—
C and C++ languages are the best for high performance, and probably have the largest quota among programming languages, implementing the backbone of all of the existing computing infrastructure, including those other programming languages. On the other hand, python usage is also very popular and growing, with its amazing simplicity, and it is being adopted as the generic language for learning and many other tasks ranging from BigData and systems to web sites. Python is also being widely used in development and systems automation “devops”, being the language of choice for many scripting tasks (build systems as SCons are written in python) or as glue between subsystems.

This talk will introduce how both C++ and Python languages can work together. As many of the methods to write python extensions typically use a raw C API, we’ll focus on how to use C++ in such extensions, and the C++ code itself.

First, I’ll briefly present the canonical python C API, and how different aspects of C++ (as Exceptions) have to be handled. Then, I will describe and compare a couple of pure C++ ways to build extensions: the reference Boost.Python and the modern, but very active and popular successor, Pybind11.

Finally, I will conclude explaining how to embed a python interpreter in a C++ application. This allows C++ programs to introduce a powerful and known language to let the users define extensions or configuration of our C++ application without requiring them to build anything.

All presented examples will be complete and working, with build scripts included, in a public repository.
—
Diego Rodriguez-Losada
SW Engineer, Freelance
Diego's passions are robotics and SW development. He has developed many years in C and C++ in the Industrial, Robotics and AI fields. He was also a University (tenure track) professor till 2012, when he quit academia to try to build a C/C++ dependency manager, co-founded startup biicode, since then mostly developing in Python. Now he is working as freelance and having fun with conan.io.
—
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
—
C++ has a pretty good type system, and modern C++ gives us a greater ability than ever before to use that type system for good: to make APIs easier to use and harder to misuse, to make our datatypes more closely express our intent, and generally to make code safer, more obvious in function and perhaps even faster.

This is an interactive session - incorporating games played between presenter and audience, even - taking a look at choices available to us as datatype and API designers, and examining how a little knowledge about the algebra of algebraic datatypes can help. We'll see why std::optional and (hopefully soon) std::variant will quickly become an essential part of everyone's toolbox, and also explore how types can be used to express not just the structure of data, but also the behaviour of objects and functions.
—
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.
—
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
—
While 2014 CppCon talk "C++ in Huge AAA Games" focused on reality for a lot of games developed at Ubisoft Montreal, this talk with focus on what was done to ship Rainbow Six Siege at 60 frames per second. Delivering a game with 5 versus 5 multi-player with heavy procedural environment destruction at 60 FPS was a constant challenge. From memory usage to lock-free solutions, a lot of developed C++ solutions are reusable outside of games. Some interesting analysis tools were also developed to find issues, and their concepts could be reused by any C++ developer caring about performance.
—
Nicolas Fleury
Technical Architect, Ubisoft Montreal
Nicolas has 13 years of experience in the video game industry, more years in the software industry in telecoms, in speech recognition and in computer assisted surgery. Technical Architect on Tom Clancy's: Rainbow Six Siege, he is one of the key Architects behind some collaboration initiatives at Ubisoft and was also Technical Architect on games like Prince of Persia. He presented at CppCon 2014 "C++ in Huge AAA Games".
—
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 traditionally used and well established parallel programming models OpenMP and MPI are both targeting lower level parallelism and are meant to be as language agnostic as possible. For a long time, those models were the only widely available portable options for developing parallel C++ applications beyond using plain threads. This has strongly limited the optimization capabilities of compilers, has inhibited extensibility and genericity, and has restricted the use of those models together with other, modern higher level abstractions introduced by the C++11 and C++14 standards.
The recent revival of interest in the industry and wider community for the C++ language has also spurred a remarkable amount of standardization proposals and technical specifications being developed. Those efforts however have so far failed to build a vision on how to seamlessly integrate various types of parallelism, such as iterative parallel execution, task-based parallelism, asynchronous many-task execution flows, continuation style computation, or explicit fork-join control flow of independent and non-homogeneous code paths.

In this talk we present the results of developing higher level parallelization facilities in HPX, a general purpose C++ runtime system for applications of any scale. The developed higher-level parallelization APIs have been designed aiming at overcoming the limitations of today's prevalently used programming models in C++ codes.
HPX exposes a uniform higher-level API which gives the application programmer syntactic and semantic equivalence of various types of on-node and off-node parallelism, all of which are well integrated into the C++ type system. We show that these higher level facilities are fully aligned with modern C++ programming concepts, they are easily extensible, fully generic, and enable highly efficient parallelization on par with or better than what existing equivalent applications based on OpenMP and/or MPI can achieve.
—
Hartmut Kaiser
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 known through his involvement in open source software projects, mainly as the author of several C++ libraries he has contributed to Boost, which are in use by thousands of developers worldwide. His current research is focused on leading the STE||AR group at CCT working on the practical design and implementation of future execution models and programming methods. His research interests are focused on the complex interaction of compiler technologies, runtime systems, active libraries, and modern system's architectures. His goal is to enable the creation of a new generation of scientific applications in powerful, though complex environments, such as high performance computing, distributed and grid computing, spatial information systems, and compiler technologies.

Website: https://www.cct.lsu.edu/~hkaiser/
—
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
—
Visual C++ supports mobile app development for Windows, Android, and iOS from a single code base, optionally with a thin platform-specific UI layer. The resulting binaries can be deployed to an emulator or to a real device and debugged on both, all from within Visual C++ . This presentation is a follow up to my session given at CppCon 2015, and as such the session will only briefly cover the basics of cross-platform mobile app development. Please view https://www.youtube.com/watch?v=2Y47g... or https://channel9.msdn.com/events/CPP/... for this material in depth. In this follow up, we go over the new features added for cross-platform development since last year. Additionally, we continue where last year’s session ended, and will go deeper on how to write your applications to have a native look-and-feel UI on each of the different platforms.
—
Marc Gregoire
Nikon Metrology
Software Architect
Belgium
Marc Gregoire has worked as a software engineer consultant for 6 years for Siemens and Nokia Siemens Networks on critical 2G and 3G software running on Solaris for telecom operators. This required working in international teams stretching from South America and USA to EMEA and Asia. Now, Marc is working for Nikon Metrology on 3D scanning software. His main expertise is C/C++, and specifically Microsoft VC++ and the MFC framework. Next to C/C++, Marc also likes C# and uses PHP for creating web pages. In addition to his main interest for Windows development, he also has experience in developing C++ programs running 24x7 on Linux platforms; for example, EIB/KNX home automation controlling and monitoring software. Since April 2007, he received the yearly Microsoft MVP (Most Valuable Professional) award for his Visual C++ expertise. Marc is the author of "Professional C++, Second and Third Edition", published by Wiley/Wrox, is the founder of the Belgian C++ Users Group (www.becpp.org), and has written a number of articles which have been published on CodeGuru and/or his personal blog. He also creates freeware and shareware programs that are distributed through his website at www.nuonsoft.com, and maintains a blog on www.nuonsoft.com/blog/. He is also passionate about traveling and gastronomic restaurants.m
—
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
—
With the increase in the available computational power, the Nathan Myhrvold's Laws of Software continue to apply: New opportunities enable new applications with increased needs, which subsequently become constrained by the hardware that used to be "modern" at adoption time. C++ itself opens the access to high-quality optimizing compilers and a wide ecosystem of high-performance tooling and libraries. At the same time, simply turning on the highest optimization flags and hoping for the best is not going to automagically yield the highest performance -- i.e., the lowest execution time. The reasons are twofold: Algorithms' performance can differ in theory -- and that of their implementations can differ even more so in practice.

Modern CPU architecture has continued to yield increases in performance through the advances in microarchitecture, such as pipelining, multiple issue (superscalar) out-of-order execution, branch prediction, SIMD-within-a-register (SWAR) vector units, and chip multi-processor (CMP, also known as multi-core) architecture. All of these developments have provided us with the opportunities associated with a higher peak performance -- while at the same time raising new optimization challenges when actually trying to reach that peak.

In this talk we'll consider the properties of code which can make it either friendly -- or hostile -- to a modern microprocessor. We will offer advice on achieving higher performance, from the ways of analyzing it beyond algorithmic complexity, recognizing the aspects we can entrust to the compiler, to practical optimization of the existing code. Instead of stopping at the "you should measure it" advice (which is correct, but incomplete), the talk will be focused on providing practical, hands-on examples on _how_ to actually perform the measurements (presenting tools -- including perf and likwid -- simplifying the access to CPU performance monitoring counters) and how to reason about the resulting measurements (informed by the understanding of the modern CPU architecture, generated assembly code, as well as an in-depth look at how the CPU cycles are spent using modern microarchitectural simulation tools) to improve the performance of C++ applications.

Slides: https://speakerdeck.com/mattpd/comput...
Resources: https://github.com/MattPD/cpplinks
—
Matt P. Dziubinski
Aalborg University
Research & Development
Denmark
Matt P. Dziubinski is affiliated with the Department of Mathematical Sciences, Aalborg University, Denmark and a Junior Fellow at Center for Research in Econometric Analysis of Time Series (CREATES). His fascination with computers started in the late 1980s with an 8-bit Atari. His current research interests include Quantitative Finance and High Performance Scientific Computing, with a focus on applied cross-platform parallel computing -- targeting multi-core CPUs as well as many-core GPGPUs. Practical implementation of these research ideas is made easier, more accessible, and even fun thanks to modern C++. Since 2008 Matt has also been sharing his passion introducing modern C++ to his students -- with computational applications in math, finance, statistics, and economics. C++ interests include generic programming, numerics, networking, and performance optimization -- while also enjoying learning about computer architecture in his spare time :-)
—
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
—
At Facebook we use C++ extensively in our backend and core infrastructure. We've recently added static reflection support for C++ to Thrift, in expectation of a first class standardized solution.

This talk demonstrates the power of reflection as a productivity enhancer, an enabler for features and an aid in managing complexity. It shows some useful functionalities that can be easily achieved through reflection in a portable and elegant way, which weren't possible before without code repetition, complex DSLs or non-portable pre-processors.

We'll cover things like pretty printers, data converters, migration to typed APIs, serialization and compilation times.

REQUIREMENTS: intermediate to advanced knowledge of template meta-programming. This talk is not aimed at people who want to learn meta-programming.
—
Marcelo Juchem
Software Engineer, Facebook
Marcelo is a Software Engineer working with core infrastructure at Facebook.
—
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
—
When we read a function declaration, what expectations do we have of the function? What requirements and limitations do we take for granted? Our unspoken assumptions about function interfaces present an obstacle to precise reasoning about programs.

Here, I will delve into the nitty-gritty procedural logic of function calls in C++, with particular emphasis on the things that often go without saying. I will present some suggestions about how we can make these implicit expectations precise, and how we can express deviation from these expectations in current and future versions of C++.

This material was previously presented at C++Now 2016, where it was named best presentation. It is a companion to my C++Now 2015 talk, "How we reason about procedural programs," but no knowledge of that material will be necessary.
—
Lisa Lippincott is Chief Software Architect at Tanium, a bay-area startup. Her claim to fame is writing one phrase appearing in the C++ standard. In her spare time, she studies mathematical logic with a category-theoretic approach.
—
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
—
Facebook has open sourced Folly, its core C++ Library and the
foundation of all of Facebook's C++ code. Folly builds practical,
efficient, and novel components on top of the standard library.
Facebook engineer Dave Watson will do a deep dive on the core
components, and investigate how they have changed over time. We will
compare its design with previous talks and proposals, and highlight
insights learned from real-world usage in Facebook's large production
codebase.

Topics include:
* Singletons in a world with fork
* Useful ThreadLocals
* Pragmatic exceptions
* Easy type conversions
* Optimizing primitives, such as shared_mutex, vector, and atomic_shared_ptr
—
David Watson
Engineer, Facebook
Dave Watson is an infrastructure engineer at Facebook. He has been focused on improving the application server stack, including improvements in RPC, load balancing, memory management, and asynchronous programming. He has contributed to many of Facebook's core services and OSS projects, including HHVM, folly, proxygen, wangle, and mcrouter. Previously he worked at F5 networks on load balancers and network monitoring tools.
—
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
—
Software for embedded systems means writing code for a microprocessor with specs straight out of the 80s. But that doesn’t mean that embedded developers should be afraid of using the best tools that modern languages have to offer. This talk will explore embedded development through the source code of a modern C++ implementation of the RTPS (Real-Time Publish/Subscribe) wire protocol. Our targeting ARM STM32 microcontrollers (but generalizable to many platforms). We will put zero-cost abstractions to the test as we attempt to fit a system conforming to a 200-page OMG specification document onto an MCU with 384 KB of RAM and 2048 KB of flash. At a higher level, we will discuss the philosophy of using high-level abstractions in a low-level environment, and seek to settle the score with old-school C microcontroller hackers.
—
Jackie Kay
Software Engineer, Marble Robotics
I write FOSS tools for the robotics community.
—
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
—
Templates - and variadic templates - are an important aspect of writing a successful library in C++; libraries that can deal with custom types the user creates greatly eases their use. Variadic templates specifically are still a new, relatively unknown and at the same time quite a buggy (in the sense of bugs in their implementations) tool, but nevertheless, they offer much easier ways of creating truly generic types and functions.

This talk will focus slightly less on variadic templates in general; the common pitfalls will be discussed, but more attention will be given to the tool of parameter pack expansion and all the contexts where it can be used, especially as a code generation tool.

The talk will start mostly from scratch, assuming the audience's general knowledge about templates. It'll introduce the idea of variadic templates and general syntax and typical techniques for their use. Next, it will head into the (mostly) unknown and buggy lands of the interesting uses of variadic packs, like unpacking a tuple into a function call using `std::integer_sequence`, the use of empty packs for a slightly easier way to work with `enable_if`. The final examples will explain the way of invoking an expression per every argument in a pack, and dispatch to appropriate version of code for each of the argument types based on runtime values, which will be used to more easily create variant visitors.
—
Michał Dominiak
Software Engineer, Nokia Networks
Bachelor of Engineering in Computer Science, studied at Faculty of Electronics at Wrocław University of Technology. Loves metaprogramming and doing as much as possible during compile time, instead of wasting precious cycles at runtime.
—
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
—
Modern C++ includes ample facilities for manipulating types a compile time. These facilities have evolved from a small bag of miscellaneous tricks to an large bag of miscellaneous tricks. It turns out we can select a subset of these tricks to build a representation of abstract algebra within the C++ type system. This methodology will help programmers select and exploit the C++ type manipulation facilities to create more transparently correct, efficient and maintainable programs.

This session does not presuppose and particular mathematical background. It depends upon only the most basic and key ideas of abstract algebra which will be explained as part of the presentation.

This work was initially inspired by work by Barton and Nackman as well as some ideas from Denotational Semantics.
—
Robert Ramey
Robert Ramey Software Development
Proprietor
Santa Barbara, CA
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