Jekyll2025-12-21T17:41:38+00:00https://ozacod.github.io/feed.xmlozacodPersonal blog - software development, C++, and developer toolsozacodStripping the Noise: 6 Heuristics for Readable C++ STL Errors2025-12-20T00:00:00+00:002025-12-20T00:00:00+00:00https://ozacod.github.io/posts/how-to-filter-cpp-errorsC++ is incredibly powerful but notoriously difficult to debug. While we have valgrind for memory leaks and gdb for complex logic, a simple syntax error can produce a wall of text that obscures the actual issue. An experienced developer learns to filter this “noise” through years of exposure, but for a junior developer, a single missing semicolon or type mismatch can result in a “wall of text” that feels more like a curse than a diagnostic.

After years of watching junior developers (and honestly, myself) drown in compiler output, I built stlfilt-go — a real-time filter that transforms C++ error logs into something human-readable. stlfilt-go is a command-line filter (written in Go) that processes stderr from GCC or Clang in real-time. It’s a modern take on Leor Zolman’s original STL Error Decryptor, updated for C++11 through C++20.

1. The “Aka” Heuristic (The Benjen Stark Rule)

In Game of Thrones, Benjen Stark says: “Nothing someone says before the word ‘but’ really counts.” In C++ logs, that word is “aka”. Clang loves to give you a complex internal type and then whisper the real name at the end. We should flip this logic and jump straight to the point.

  • Raw: note: candidate expects 'value_type' (aka 'std::basic_string<char32_t>')
  • Simplified: note: expected 'u32string'

2. Collapsing I/O Stream Bloat

I/O streams are some of the wordiest templates in the library. Because std::basic_ifstream is actually a complex hierarchy of traits and character types, a simple mismatch can produce lines of text that obscure the actual filename and line number.

  • Raw: std::basic_ifstream<char, std::char_traits<char>>
  • Simplified: ifstream

This applies to istringstream, ofstream, and streambuf as well. Stripping the basic_ prefix and the character traits allows you to see the actual stream type you defined in your code.

3. Killing “Allocator Bloat”

Almost every STL container has a hidden std::allocator parameter. While technically accurate, it’s 99% irrelevant during a syntax error. By treating these as invisible defaults, a 100-character line shrinks significantly.

  • Raw: std::map<int, MyClass, std::less<int>, std::allocator<std::pair<const int, MyClass>>>
  • Simplified: map<int, MyClass>

4. Deciphering Internal Iterators and Traits

Compilers often leak the “plumbing” of the STL. For example, a vector iterator is often a __normal_iterator wrapping a raw pointer, and modern C++ introduces traits like __unwrap_ref_decay_t.

  • Iterators: __gnu_cxx::__normal_iterator<int*, vector<int>> to vector<int>::iterator
  • Traits: __unwrap_ref_decay_t<T> to T
  • Smart Pointers: unique_ptr<int, default_delete<int>> to unique_ptr<int>

5. Path Shortening (The “Signals over Noise” Rule)

When you are deep in a project, you don’t need to see the full absolute path of every system header. Seeing /Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/include/c++/v1/vector tells you nothing new—you just need to know the error happened in vector. stlfilt-go strips these absolute paths down to the base filename.

  • Raw: /usr/include/c++/11/bits/stl_vector.h:1234:20:
  • Simplified: vector:1234:20:

6. Namespace and Attribute Stripping

Compilers decorate function signatures with internal macros and namespaces that aren’t part of the code you actually wrote. Attributes like _LIBCPP_HIDE_FROM_ABI or internal namespaces like __gnu_cxx add horizontal bulk without adding diagnostic value.

  • Raw: _LIBCPP_HIDE_FROM_ABI void push_back(const value_type& __x)
  • Simplified: void push_back(const value_type&)

Repo: https://github.com/ozacod/stlfilt-go

]]>ozacodWhy I Built cpx2025-12-12T00:00:00+00:002025-12-12T00:00:00+00:00https://ozacod.github.io/posts/why-i-built-cpxThere are too many ways to start, build, and cross-build a C++ project. Unlike Rust’s cargo or Go’s go tool, C++ lacks a unified toolchain to easily initialize a project, run tests, or manage builds. Dependency management is fragmented across options like vcpkg, Meson, and Bazel, none of which save you from the burden of manual configuration.

Cpx aims to provide an opinionated template to jumpstart your C++ projects while retaining the flexibility to choose your preferred build system, testing framework, and benchmarking library. Once your project is created, you shouldn’t need to memorize different commands for every task. Cpx unifies these workflows into simple, intuitive commands: cpx build, cpx run, cpx test, and cpx bench.

Unified Workflow

While commands like vcpkg add port spdlog aren’t inherently difficult, remembering context-specific syntax for every build system is a friction point.

Cpx abstracts this away. Whether you’re using CMake, Meson, or Bazel under the hood, the commands you type remain the same:

cpx build          # Build the project
cpx run            # Run the main executable
cpx test           # Run all tests
cpx bench          # Run benchmarks
cpx add spdlog     # Add a dependency

Opinionated but Flexible

Cpx comes with sensible defaults. When you run cpx new my-project, you get a ready-to-compile project structure with CMake, GoogleTest, and Google Benchmark configured out of the box.

But if you prefer Meson over CMake, or Catch2 over GoogleTest, you can easily switch. The goal is to reduce boilerplate, not enforce a particular stack.

Cross-Compilation Made Simple

One of the most painful aspects of C++ development is cross-compiling for different platforms. Cpx integrates with Docker to make this seamless:

cpx add-target linux-arm64
cpx build --target linux-arm64

No manual toolchain setup. No fiddling with sysroots. Just specify the target and build.

What’s Next

Cpx is still in active development. The roadmap includes better IDE integration, support for more build systems, and a package registry for sharing project templates.

If you’re tired of the fragmented C++ tooling ecosystem, give cpx a try. Check out the GitHub repository to get started.

]]>ozacod