C++ Documentary: A Deep Dive Into the Past and Future

Herb Sutter just released a documentary on C++, and it's getting a lot of attention on Hacker News. The timing is perfect: despite its reputation for complexity, C++ is growing faster than ever. I watched the documentary and read through the HN discussion, and here's what I think matters.

C++ Documentary: The Full Story

The documentary, produced by Herb Sutter (a key figure in C++ standardization), covers the language's entire history — from its origins as "C with Classes" to modern C++20 and beyond. It features interviews with Bjarne Stroustrup, other committee members, and industry users. The film explores the language's design philosophy, its role in performance-critical domains (games, finance, AI), and the ongoing challenges of evolution.

One stat that jumps out: as of Q3 2025, C++ is the fastest-growing of the top four languages, with a +90% increase in users over the past 3.5 years. The documentary attributes much of this to the rise of AI and machine learning, where C++ drives the underlying infrastructure. It's a compelling look at a language that refuses to fade.

Why the Documentary Resonates on HN

The HN thread (with 92 points and 18 comments) shows a mix of appreciation and frustration. The top comment captures the love-hate relationship many developers have:

It's surprising that C++'s development trend continues. When a game or program is made with C++, it's usually nice because performance is mostly guaranteed. But if someone told me to write C++ myself, I'd cry. There's too much to memorize, and the standards are too varied. ... I'd be happy if someone else wrote it, but it's not a language I want to write myself.

Others found the documentary itself delightful. One commenter wrote:

Since I've been working in C++ a lot recently I decided to watch the video as I waited for a build to complete. So the length is about right. And fortunately, the video is a delight!

There's also curiosity about whether this is part of a series (after Python, Clojure, etc.) and whether every language will get its own documentary. And a pointed question: "Because of AI, right?" referring to the growth stats.

My Take on C++ Growth and Modern Practices

C++ is hard. No one denies that. But the documentary makes a strong case that the difficulty is often overstated, especially if you focus on modern C++ (C++17/20) rather than the legacy mess. The language is complex because it needs to serve many masters: high-level abstraction, zero-cost abstraction, backward compatibility, and extreme performance.

The growth driven by AI is real. Machine learning frameworks like TensorFlow and PyTorch have C++ backends. Inference engines, game engines, browsers — all rely on C++. The documentary doesn't shy away from the pain points, but it shows that the community is actively working on tooling and education to make the language more accessible.

What I appreciate is the emphasis on "modern" C++. The days of raw pointers and manual memory management are not gone, but smart pointers, lambdas, and the STL have transformed the experience. The documentary showcases this evolution without sugarcoating the remaining friction.

Modern C++ features that matter:

• RAII (Resource Acquisition Is Initialization) eliminates resource leaks.
• Smart pointers (std::unique_ptr, std::shared_ptr) replace manual new/delete.
• Lambdas enable concise functional-style code.
• constexpr allows compile-time computation.
• Ranges and views (C++20) simplify data processing.

Here's a quick example of how C++ has improved:

#include <memory>
#include <vector>
#include <algorithm>

auto process_data(const std::vector<int>& input) {
    auto result = std::make_unique<std::vector<int>>();
    std::copy_if(input.begin(), input.end(), std::back_inserter(*result),
                 [](int x) { return x > 0; });
    return result;  // no manual delete, move semantics
}

No raw pointers. No new/delete. Just clear intent with RAII.

The documentary also highlights the importance of tools. Modern C++ builds rely on CMake, package managers like vcpkg or Conan, and static analyzers. If you're starting a C++ project today, adopt these from day one.

For AI/ML builders, C++ is the backbone. If you're working on inference optimization or custom kernels, learning modern C++ is a massive productivity boost.

What This Means for C++ Developers

If you're building systems where performance matters — game engines, real-time trading, embedded devices, AI inference — C++ remains unbeatable. But you need to embrace the modern way.

• Use a package manager (vcpkg or Conan) to manage dependencies.
• Adopt CMake for build configuration.
• Enable compiler warnings and static analysis.
• Write unit tests with frameworks like Google Test or Catch2.

Modern C++ is not your dad's C++. It's safer, more expressive, and still blazing fast.

Final Verdict: Should You Watch?

If you work in systems programming, game development, finance, or AI infrastructure — yes, you should watch this documentary and reconsider your relationship with C++. It's not as painful as you remember if you commit to modern practices. If you're building web apps or scripts, you can ignore C++. But understanding its strengths and weaknesses will make you a better engineer regardless.

The documentary is a great resource for anyone curious about why C++ persists and thrives. Watch it, read the HN thread, and check Herb Sutter's original announcement. For deeper dives, explore isocpp.org and cppreference.com.

Ultimately, C++ isn't for everyone — but the documentary shows it's for more people than you'd think.