~/conference

CppCon 2014

Name: CppCon 2014
Start: 2014-09-07
End: 2014-09-12
Location: Bellevue

date:2014-09-07..2014-09-12

location:Bellevue, United States

website:https://cppcon.org/2014/

series:CppCon · 11 editions

editions:[CppCon 2014, CppCon 2015, CppCon 2016, CppCon 2017, CppCon 2018, CppCon 2019, CppCon 2020, CppCon 2021, CppCon 2022, CppCon 2023, CppCon 2024]

tags:[rust]

title	author	length
Pimp my Log()	Marc Eaddy	12m
Macro-plus-template logging that packs streamed arguments into nested pairs so the compiler sees a single call and can optimize away intermediate operator<<… Lightning on
Boostache	Michael Caisse	06m
A template engine called Boostache is built in a week as part of Library in a Week and uses Boost.Spirit to parse template syntaxes (Mustache, Kate, Django)… Lightning on
Cross Platform GUID Association with Types	Vladimir Morozov	12m
Implements cross-platform GUID-for-type association that replaces MSVC-only __declspec attributes with macro markers that expand to constexpr functions and a… Lightning on
Test-Drive Performance	Lenny Maiorani	07m
Concrete microbenchmarks compare vector vs deque as a stack for depth‑first traversal when child counts are unknown, using the LVM‑derived example code on… Lightning on
C++ Package Manager	Boris Kolpackov	09m
Proposes a C++ package manager that downloads and builds per exact compiler/configuration so Visual Studio (or any IDE) gets a binary matching bitness… Lightning on
Convergent Evolution	Karl Niu	08m
Argues that C++ concepts and Haskell type classes are convergent solutions, framed by the Curry–Howard correspondence; demonstrates with a concrete example… Talk on
C++ Hardware Register Access	Ken Smith	07m
Claims a safer replacement for volatile derefs by modelling registers as templates with a mutability policy and a compile-time mask that yields compile errors… Lightning on
My Four Year Bug	Kevin Carpenter	05m
Legacy MFC financial app for interest‑rate simulations keeps arrays of doubles (200–300k) with 20–30 kept in memory, migrates from Visual Studio 2005 to 2010… Lightning on
Wishful Thinking	Roland Bock	05m
Argues for making names first-class in templates, claiming a name tuple lets templates configure member names so structs can be accessed by name not just type… Lightning on
Anatomy of a Smart Pointer	Michael VanLoon	11m
Covers concrete designs and tradeoffs: object‑based vs container‑based reference counting with the actual cost differences and simpler smart‑pointer logic… Lightning on
The New Old Thing, of Fun with Lambdas	Jonathan Caves	11m
Example code uses generic lambdas and variadic pack expansion capture and exposes divergent behavior: Clang prints 1 2 3 4, GCC prints 4 3 2 1, one build of… Lightning on
Software Transaction Memory, For Reals	Brett Hall	17m
Claim: software transactional memory runs in real production code. Used for three years inside dynamics data collection and analysis at Wyatt Technology, with… Lightning on
Writing A Python Interpreter for Fun & Profit	Shy Shalom	07m
A tiny Python VM compiles CPython bytecode and executes it with a simple C++ interpreter that actually works: a single recursive run_code loop with a big… Lightning on
C++ Puzzlers	Leor Zolman	15m
A rapid sequence of concrete C++ brainteasers with code and answers: shows using directive vs using declaration and why one compiles and the other errors… Lightning on
Assertions of Competence	Michael VanLoon	07m
Asserts are argued to be for declaring invariants and catching things that should never happen not for user-facing error handling, with the concrete point that… Lightning on
Less Code = More Software	Peter Sommerlad	06m
Claims a concrete method called Decremental Development that aims to reduce code to 10% of its original size while keeping essential functionality and… Lightning on
Return Values Take A Closure Walk	Martin Troxler	08m
Claim: pass return values up the stack without knowing their concrete type by decoupling call site and implementation. Implementation uses std::function type… Lightning on
C++ Conferences	Jens Weller	13m
A rapid practical tour of current C++ conferences names venues and what actually happens: CppNow runs about 150 attendees over five days with deep Boost and… Lightning on
Rolling Your Own Circuit Simulator	Jeff Trull	13m
A compact pipeline shows a working circuit simulator built from parts rather than promises: it converts nets into a modified nodal analysis system using… Lightning on
Introduction to Undodb	Julian Smith	14m
A reversible debugger called UndoDB provides reverse execution via snapshots plus deterministic record-and-replay, works on unmodified Linux (not macOS or… Lightning on
Microsoft w/ C++ to Deliver Office Across Different Platforms, Part II	Zaika Antoun	57m
Microsoft uses a single modern C++ source base plus VC++ and Clang/LLVM toolchains to ship Office and SQL Server PowerBI across iOS, Android, Windows, and Mac… Talk on
Microsoft w/ C++ to Deliver Office Across Different Platforms, Part I	Zaika Antoun	01h 00m
Claims using C++ to run Office and PowerBI from a single modern C++ source base across iOS Android Windows and Mac; tools include VC++ and Clang/LLVM, MVVM… Talk on
Boost.Asio and Boost.Serialization, Part II	Bryce Adelstein Lelbach	33m
Prototype message-passing runtime uses Boost.Asio and Boost.Serialization to send polymorphic actions over TCP, implements a zero-copy archive (two‑pass… Talk on
Boost.Asio and Boost.Serialization, Part I	Bryce Adelstein Lelbach	58m
A concrete prototype message system uses Boost.Asio for networking and Boost.Serialization for object transmission, implementing an echo server, two-thread… Talk on
Optimization Tips - Mo' Hustle Mo' Problems	Andrei Alexandrescu	58m
Slides and hhvm source show concrete wins and losses: changing GCC flags flips a 5% regression in GCC 4.8 to a 2% win; inlining one implicitly generated… Talk on
Meet the Authors	Chandler Carruth, John Lakos, Herb Sutter, Ade Miller, Alex Allain, Kate Gregory, Michael S Wong, Peter Sommerlad, Scott Meyers	01h 31m
Panelists claim a compact Tour of C++ is 180 pages that settles “what to read,” describe using clang-format to stop arguing about code layout, and explain… Talk at Pascal on
Advanced Weapons and Tactics	Boris Kolpackov	01h 05m
Hiding a relational database behind an ORM causes real performance and scalability problems, and ODB claims to fix that without falling back to raw JOINs or… Talk at Euler on
Efficiency with Algorithms, Performance with Data Structures	Chandler Carruth	01h 14m
Claim: efficiency comes from doing less work (algorithms) and performance from making memory accesses fast (data structures). Evidence: CPUs spend ~50–75% of… Talk at Pascal on
cppreference.com: documenting C++ one edit at a time	Nate Kohl	33m
A community-run documentation site for C++ evolves from hand-rolled Perl + static HTML to a CMS to Dokuwiki and finally MediaWiki, handling ~200,000 unique… Talk at Gauss on
Common-sense acceleration of your MLOC build	Matt Hargett	01h 04m
Describes concrete steps that cut multi-hour builds to minutes: mounting /tmp as a ram disk for link-heavy IO, benchmarking SSD vs 15k‑RPM SAS and preferring… Talk at Gauss on
Emscripten and asm.js: C++'s role in the modern web	Alon Zakai	59m
LLVM+clang → Emscripten emits JavaScript (an asm.js subset) that views program memory as an ArrayBuffer heap with typed‑array views, uses tricks like or\|0… Talk at Newton on
What the committee did next!	Alisdair Meredith	01h 07m
Committee reorganizes into about 13 study groups and pursues 8+ Technical Specifications to speed releases after C++11 took roughly eight years and C++14 only… Talk at Euler on
Defensive Programming Done Right, Part II	John Lakos	01h 06m
Library-level defensive checks are implemented as three assertion levels (optimized ≲5% cost, regular ≈5–20%, expensive >20%), selectable per build or via… Talk at Descartes on
Defensive Programming Done Right, Part I	John Lakos	01h 00m
Argues that libraries should let the owner of main choose a runtime budget for precondition checks and the policy (for example abort throw spin) for… Talk at Descartes on
How you can make a Boost C++ Library	Robert Ramey	01h 02m
Argues C++ needs more high‑quality Boost libraries and many authors drop out from the paperwork not the code, walks through www.blincubator.com and uses safe… Talk at Leibnitz on
Lock-Free Programming (or, Juggling Razor Blades), Part II	Herb Sutter	01h 11m
Shows how to implement a lock‑free singly linked list using C++ atomics and smart pointers with concrete code, not high‑level handwaving: uses… Talk at Pascal on
Lock-Free Programming (or, Juggling Razor Blades), Part I	Herb Sutter	01h 00m
Concrete claims and usable patterns: uses std::atomic<T> and compare_exchange to publish complex structures with a single atomic handoff, fixes double-checked… Talk at Pascal on
Introduction to C++ AMP (GPGPU Computing)	Marc Gregoire	53m
Demoed C++ AMP code converts a parallel CPU loop into a GPU kernel via parallel_for_each and array_view and hits concrete speedups: a laptop N‑body goes from… Talk at Descartes on
Rebuilding Boost Date-Time for C++11	Jeff Garland	01h 06m
Rebuilds Boost.Date_Time around C++11/14 features aiming for a smaller faster v2 that can be proposed for the standard — default-constructed dates become epoch… Talk at Leibnitz on
Adventures In Updating A Legacy Codebase	Billy Baker	44m
Codebase with 20+ years of history moves to C++11 and 64-bit: automated rewrites run with clang-modernize but one transform creates a subtle runtime crash when… Talk at Newton on
Viewing The World Through Array-Shaped Glasses	Łukasz Mendakiewicz	22m
Claims that C++ needs a unified view for contiguous data and presents N3851 which defines array_view and strided_array_view, multi‑dimensional index and bounds… Talk at Gauss on
An Overview of C++11/14, Part II	Leor Zolman	01h 10m
Survey lists concrete C++11/14 features with code-level consequences: override/final specifiers to force compile-time checks, equals delete/default to ban or… Talk at Leibnitz on
An Overview of C++11/14, Part I	Leor Zolman	01h 02m
Survey lists concrete language changes and shows code that compiles: uses auto and decltype for return types, rvalue references and move semantics for… Talk at Leibnitz on
Generic Programming with Concepts Lite, Part II	Andrew Sutton	01h 05m
Concepts Lite claims that adding named constraints to templates makes library code readable and gives precise diagnostics by checking constraints at the point… Talk at Newton on
Generic Programming with Concepts Lite, Part I	Andrew Sutton	58m
Concepts Lite claims to move constraints into declarations so template arguments are checked at the point of use using a requires clause, giving readable… Talk at Newton on
Overview of Parallel Programming in C++	Pablo G Halpern	01h 02m
Covers concrete claims, tools and costs: multicore is necessary as clock speeds stall, typical phones have 2–4 cores, laptops 4–8, servers dozens, a Zeon E7… Talk at Pascal on
Type Deduction and Why You Care	Scott Meyers	01h 10m
Covers how C++11/14 actually deduce types: three template-based patterns plus universal references and special rules for auto vs decltype(auto), lambda… Talk at Fermat on
Persisting C++ Classes in Relational Databases with ODB	Boris Kolpackov	01h 03m
A working C++ ORM is demonstrated: ODB generates mapping code from C++ class declarations via a GCC plugin, targets SQLite PostgreSQL MySQL MS SQL Server… Talk at Euler on
How HHVM Uses Modern C++ for Fun and Profit (Literally)	Drew Paroski	01h 11m
HHVM is a production JIT for PHP that claims 10x throughput and 75% memory reduction versus older PHP over several years; the implementation shows the… Talk at Euler on
Modernizing Legacy C++ Code	James McNellis, Kate Gregory	59m
http://www.cppcon.org -- Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/CppCon/CppCon2014 -- C++ is… Talk at Descartes on
The Committee Experience	Alisdair Meredith	01h 09m
A concrete checklist: who votes (national bodies via SC22 then ISO), how progress happens (mailings three weeks before meetings, papers in HTML/PDF/ASCII… Talk at Gauss on
Modern Template Metaprogramming: A Compendium, Part II	Walter E. Brown	59m
http://www.cppcon.org — Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/CppCon/CppCon2014 -- Template… Talk at Pascal on
A Deep Dive into 2 Cross-Platform Mobile Apps Written in C++	T. Grue, S. Kabbes	01h 01m
Concrete claims and outcomes only: Dropbox builds two apps, Mailbox and Carousel, by sharing a shared C++ model for syncing, storage and view models and using… Talk at Leibnitz on
Modern Template Metaprogramming: A Compendium, Part I	Walter E. Brown	01h 00m
Demonstrates concrete template techniques and reproduces standard-library facilities: type traits like rank and remove_const, alias helpers (_t and _v), SFINAE… Talk at Pascal on
Practical Functional Programming in C++	Bryce Adelstein Lelbach	46m
Argues that functional techniques are practical in modern C++ by showing actual code: uses std::function and C++11 lambdas to store callbacks in a MUD‑style… Talk at Pascal on
UI prototyping and development for multiple devices in C++	John "JT" Thomas	01h 10m
Shows how C++ actually ships multi‑device UIs: uses a Clang/LLVM toolchain plus added RTTI, properties and closures to host live components in the IDE, streams… Talk at Euler on
Another fundamental shift in Parallelism Paradigm?	Michael S Wong	01h 07m
OpenMP 4.0 actually shows how to offload work and data to accelerators with concrete primitives: omp target and declare target for code offload, map(to… Talk at Gauss on
Exception-Safe Code, Part III	Jon Kalb	01h 04m
Clearly stated, actionable guidelines for C++11/14 exception safety: make_shared/make_unique and smart pointers for ownership, non‑throwing swap (or noexcept… Talk at Descartes on
Exception-Safe Code, Part II	Jon Kalb	01h 00m
http://www.cppcon.org — Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/CppCon/CppCon2014 -- Are you… Talk at Descartes on
Exception-Safe Code, Part I	Jon Kalb	01h 01m
Covers concrete rules and examples: the basic/strong/nothrow guarantees, when no‑throw is required (destructors, cleanup, swap/move), and how RAII or move… Talk at Descartes on
0xBADC0DE	Jens Weller	51m
Examples show single-line disasters like the duplicated "goto fail" and the Heartbleed bug and claim modern C++ features already eliminate many classic… Talk at Leibnitz on
Pragmatic Type Erasure: Solving OOP Problems w/ Elegant Design Pattern	Zach Laine	44m
Claims that proper type erasure solves lifetime, ownership and multiple-interface OOP problems without losing performance and compares hand-rolled… Talk at Pascal on
Asynchronous Computation in C++	Hartmut Kaiser	01h 06m
Claims a C++ runtime called HPX implements futures/async/dataflow and actually runs: measured ~25 million lightweight threads per second, supports distributed… Talk at Newton on
Decomposing a Problem for Parallel Execution	Pablo G Halpern	01h 05m
Shows concrete implementations: star counting and the n‑body simulation parallelized with Cilk Plus and compared to TBB/OpenMP; per-thread reducers remove… Talk at Newton on
Embind and Emscripten: Blending C++11, JavaScript, and the Web Browser	Chad Austin	56m
Explains concrete tooling and results: Emscripten compiles C++ to asm.js (~half native speed) and Embind exposes C++ libraries to JavaScript with a tiny… Talk at Leibnitz on
C++11 in the Wild: Techniques from a Real Codebase	Arthur O'Dwyer	01h 05m
Concrete takeaways: Auto macro implements scope‑exit RAII with lambdas, token‑pasting and __COUNTER__, compiles down to inlined, zero‑overhead code… Talk at Newton on
Using C++ on Mission and Safety Critical Platforms	Bill Emshoff	01h 00m
http://www.cppcon.org — Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/CppCon/CppCon2014 -- The… Talk at Descartes on
Make Simple Tasks Simple!	Bjarne Stroustrup	01h 38m
Example-driven claims and concrete tools: use auto and range-for to collapse iterator noise, replace hand-rolled loops with std::find_if or std::all_of, return… Talk at Fermat on
Elevate Your Code to Modern C++11 with Automated Tooling	Peter Sommerlad	01h 03m
Automated Eclipse CDT–based refactoring built over nine years performs concrete edits: it rewrites macros to constexpr or template functions, converts C arrays… Talk at Newton on
Writing Data Parallel Algorithms on GPUs	Ade Miller	01h 07m
Concrete algorithm patterns and working code dominate: examples using the C++ AMP Algorithms Library show array_view lazy copy and const/discard hints that… Talk at Leibnitz on
Implementing Wire Protocols with Boost Fusion	Thomas Rodgers	55m
Claims a reusable serializer that maps nonstandard binary exchange messages into modern C++ types using Boost Fusion and Boost.MPL rather than packed C… Talk at Euler on
Grill the Committee	Jon Kalb, Marshall Clow, John Lakos, Chandler Carruth, Herb Sutter, Alisdair Meredith, Howard Hinnant, Michael S Wong, Pablo G Halpern, Stefanus Du Toit, Stephan T. Lavavej, Walter E. Brown, Nevin Liber	01h 29m
Lots of concrete, behind‑the‑scenes detail about what actually makes it into the standard: discussions name features (move elision, polymorphic and scoped… Talk at Pascal on
Pragmatic Unit Testing in C++	Matt Hargett	01h 07m
Argues unit testing only pays when paired with static and run‑time analysis as an “iron triangle,” and shows concrete steps to get ROI in legacy C++: move… Talk at Newton on
The Perils of Strict Aliasing	Andy Webber	07m
Strict aliasing makes type-punning through differently typed pointers undefined behavior so swapping a uint32 by accessing it as uint16 can silently break… Lightning at Leibnitz on
Making Allocators Work, Part II	Alisdair Meredith	01h 08m
Explains how C++11 turns the broken C++98 allocator parameter into a usable system by showing the actual implementation: SFINAE tricks with SFINAE and decltype… Talk at Descartes on
C++ Memory Model Meets High-Update-Rate Data Structures	Paul E. McKenney	01h 13m
Claims that specialized update-side techniques can match RCU and hazard pointers lead to a concrete prototype: a pair of binary-search trees that perform… Talk at Descartes on
Costless Software Abstractions for Parallel Architectures	Joel Falcou	01h 22m
Claims a C++ generative/meta programming approach yields near zero overhead, using expression templates and Boost/Proto to generate skeletons bound to runtimes… Talk at Euler on
Hourglass Interfaces for C++ APIs	Stefanus DuToit	01h 06m
Explains the concrete hourglass pattern: rich C++ API and implementation separated by a thin C89 ABI layer, with code for C++98 and C++11. Shows exact… Talk at Leibnitz on
C++ Test-driven Development	Peter Sommerlad	01h 00m
Concrete claim: test-driven cycles produce simpler, safer C++ and refactoring speeds up with IDE help. Demonstrations use Eclipse CDT and Cevelop tooling to… Talk at Pascal on
Making Allocators Work, Part I	Alisdair Meredith	49m
Explains the concrete C++11/14 changes: introduces allocator_traits and a polymorphic allocator runtime model, shows a built example — a monotonic memory… Talk at Descartes on
Parallelizing the Standard Algorithms Library	Jared Hoberock	40m
The talk presents a concrete proposal: parallel overloads for the C++ standard algorithms, implemented via execution policy objects (examples: seq, par… Talk at Euler on
The Implementation of Value Types	Lawrence Crowl	01h 00m
Value types require concrete choices: use a representation that minimizes padding and caches hot fields, make copies trivially copyable when possible, and… Talk at Newton on
Multiplatform C++	Edouard Alligand	48m
http://www.cppcon.org — Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/CppCon/CppCon2014 -- C++ is a… Talk at Gauss on
Making C++ Code Beautiful	James McNellis, Kate Gregory	56m
Argues that C++ becomes readable by replacing macros with enum classes, using RAII destructors for cleanup, and preferring lambdas and algorithms (range-based… Talk at Pascal on
How to call C libraries from C++	Lisa Lippincott	01h 00m
Shows a concrete method and a tiny support library for converting POSIX APIs into idiomatic C++: a short set of design rules (type-for-type… Talk at Euler on
Founding C++ User Groups	Jon Kalb, Jens Weller	56m
Practical how-to: a C++ community grows when someone actually signs up venues and recruits organizers not slogans. Meeting C++ becomes a website and monthly… Talk at Descartes on
Large-Scale Refactoring @ Google	Hyrum Wright	57m
Google builds a compiler-driven refactoring pipeline (indexer + ClangMR (clang + map reduce)) that generates, shards, formats and tests edits across a mono… Talk at Pascal on
The Philosophy of Google's C++ Code	Titus Winters	01h 00m
Google documents why specific rules exist and what actually changed: the codebase spans 100 million lines of code, an indexer called kaith lets maintainers… Talk at Pascal on
Meta Techniques: Heterogeneous Polymorphism & Fast Prototyping at Facebook	M. Juchem	01h 03m
Claims that full features can be generated at compile time and used to prototype a small database engine that stores vectors maps and strings rather than… Talk at Newton on
C++ on Mars: Incorporating C++ into Mars Rover Flight Software	Mark Maimone	01h 26m
Mars rovers run autonomous navigation code in C++ on VxWorks with rad‑hard PowerPC CPUs, tight memory (32 MB address space, ~10 MB for much code) and a… Talk at Fermat on
The Canonical Class	Michael Caisse	01h 06m
Concrete advice about C++11 class design: prefer use =default or =delete explicitly for each special member, decide whether default construction is meaningful… Talk at Newton on
A CTO's guide to Modern C++	Matt Hargett	01h 09m
Lists concrete operational wins and failures: use trunk-based development and small commits to get single-hash deploys, add pre-commit hooks and CI to… Talk at Gauss on
How Ubisoft Develops Games for Multicore - Before and After C++11	Jeff Preshing	01h 05m
Ubisoft Montreal documents concrete concurrency patterns—pipelining, dedicated threads, task schedulers—and the custom concurrent objects actually implemented… Talk at Descartes on
Types Don't Know #	Howard Hinnant	01h 01m
Proposes a concrete hashing infrastructure that decouples algorithms from types into three roles (type authors provide hash_append, algorithm authors provide… Talk at Leibnitz on
Gamgee: A C++14 library for genomics data processing and analysis	Mauricio Carneiro	01h 08m
Broad genomics pipeline is reimplemented in a C++14 library to remove Java memory indirection, use contiguous byte arrays, shared_ptr-backed views and… Talk at Gauss on
Practical Cross-Platform Mobile C++ Development	Alex Allain, Andrew Twyman	01h 04m
Claim: Dropbox moves complex logic into a single C++ core and keeps the UI native, uses Objective‑C++ and JNI bridges and a code‑generator (Djinni/Genie) so… Talk at Newton on
Async sequences and algorithms to compose them	Kirk Shoop	53m
Argues that values arriving over time need the same algorithm set as STL ranges and shows a concrete C++ implementation using RX CPP, adapters for… Talk at Euler on
Simulating the Universe Using Modern C++	Vincent Reverdy	59m
Describes a production-scale numerical experiment: the Full Universe Run simulating 13.7 billion years of structure formation on the Curie thin‑nodes… Talk at Gauss on
What's New In The C++14 Library	Alisdair Meredith	59m
C++14 delivers concrete library changes: new user literals (binary, time suffixes, complex 'i'), digit separators, and utilities like make_unique, exchange and… Talk at Newton on
Unicode in C++	James McNellis	01h 00m
C++ lacks robust built‑in Unicode support but gains char16_t/char32_t and Unicode string literals in C++11; the ecosystem leans on UTF‑8 for interchange, warns… Talk at Leibnitz on
C++ in Huge AAA Games	Nicolas Fleury	49m
Codebase compiles into a single executable with millions of lines (3.5M+C++ for one game), and iteration time targets are concrete: distributed building gives… Talk at Descartes on
Bringing CLANG/LLVM To Windows	John "JT" Thomas	01h 01m
Embarcadero ports a front end and runtime onto Clang/LLVM and ships the first commercial 64-bit Windows tool chain, plus iOS and Android targets, with C++11… Talk at Euler on
Practical Type Erasure	Cheinan Marks	01h 01m
Shows a real production configuration system built with boost any and type erasure that actually runs on GCC 4.8/4.9 and cling 3.4 but not tested on Windows… Talk at Descartes on
Polymorphism with Unions	Jason Lucas	59m
Argues that tagged unions replace brittle class hierarchies by collapsing finals into a value type with a vtable-like tag, shows a C++14 implementation on… Talk at Euler on
Using C++ to Connect to Web Services	Steve Gates	58m
http://www.cppcon.org — Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/CppCon/CppCon2014 -- Many… Talk at Newton on
sqlpp11, An SQL Library Worthy Of Modern C++	Roland Bock	59m
A C++11 templated EDSL called sqlpp11 claims to make SQL type-safe by building SQL expression trees at compile time so most mistakes surface as compile-time… Talk at Gauss on
Sanitize your C++ code	Kostya Serebryany	01h 02m
Concrete claims and hard numbers: AddressSanitizer finds buffer overflows and use‑after‑free, ThreadSanitizer detects data races and deadlocks, MemorySanitizer… Talk at Pascal on
Lock-free by Example	Tony Van Eerd	59m
http://www.cppcon.org — Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/CppCon/CppCon2014 -- Dive… Talk at Descartes on
STL Features And Implementation Techniques	Stephan T. Lavavej	01h 00m
Covers specific STL changes from C++11/14 and how they are implemented in Visual C++ via Dinkumware sources including working code on GitHub, demonstrates… Talk at Pascal on
Metaprogramming with Boost.Hana: Unifying Boost.Fusion and Boost.MPL	Louis Dionne	01h 00m
Claims a working C++14 library, Boost.Hana, that unifies Boost.MPL and Boost.Fusion under a single purely functional interface and actually implements… Talk at Leibnitz on
Quick Game Development with C++11 / C++14	Vittorio Romeo	53m
Build claim: an Arkanoid/Breakout clone in ~200–300 lines using C++11/14. Tools actually used: SFML for 2D rendering/input and modern C++ features —… Talk at Leibnitz on
Creative Coding with C++	Andrew Bell	59m
C++ codebase Cinder powers interactive exhibits, phone/tablet apps and museum pieces, is BSD licensed and runs on Windows iOS and WinRT with unofficial… Talk at Newton on
...Scaling Visualization in concurrent C++ programs	F. Pikus	01h 03m
High-resolution timeline profiling instruments code with RAII-style collectors that allocate into a thread-safe memory pool and hand off to processor threads… Talk at Pascal on
Data-Oriented Design and C++	Mike Acton	01h 28m
The claim is stark: transformation of data is the only purpose and common C++ idioms in console games actively impede that goal. Concrete examples show tight… Talk at Fermat on
await 2.0: Stackless Resumable Functions	Gor Nishanov	54m
C++17 proposal claims stackless resumable functions that scale to 100,000,000 concurrent coroutines and expose await and yield as keywords; implementation… Talk at Descartes on
What did C++ do for Transactional Memory?	Michael S Wong	01h 00m
SG5 pushes a concrete TM proposal into C++ with language words like atomic_cancel semantics and synchronize alongside transaction safe/unsafe annotations… Talk at Leibnitz on
Accept No Visitors	Yuriy Solodkyy	01h 06m
Visitor Design Pattern is framed as a workaround that forces invasive accept methods, lots of boilerplate, control inversion and poor class extensibility; the… Talk at Newton on
Hardening Your Code	Marshall Clow	59m
Practical, specific hardening steps and tools rather than platitudes: use version control and git bisect to find offending commits, build and keep zero… Talk at Pascal on
Back to the Basics! Essentials of Modern C++ Style	Herb Sutter	01h 40m
Revisits concrete rules: default to auto by default for locals, prefer range-for with auto& for whole-collection loops, and use make_unique/make_shared instead… Talk at Fermat on
Paying for Lunch: C++ in the ManyCore Age	Herb Sutter	01h 16m
Panel lays out concrete progress and gaps: a parallel algorithms TS with prototype GitHub implementations, a move from std::async toward executors and clearer… Talk at Fermat on
nothing matches

-- 120 of 120 talks indexed --