174

Media

Video

Coming soon.

Podcast

Coming soon.

Why CMake sucks

The explicit configure + generate step, touched on in the article, precludes most forms of dynamic dependency generation. Making this work with C++ modules has been very painful.

Follow-ups by Tomasz Wisniewski:

See also:

Safe C++

Safe C++ is an extension of C++. It adds a robust safety model, but it’s not a new language.

OH: "Sean Baxter thinks he can add arbitrary stuff to C++ and still call it C++".

Reddit

Sean Baxter’s Circle talk at Bloomberg (2023)

https://www.youtube.com/watch?v=x7fxeNqSK2k

Quotes from the talk:

It’s easy to fix C++

The fix is Circle, of course.

Each textual file has an active mask of features. Per-file, not per translation unit. Files don’t inherit features. Library files (.h files): Feature mask has no effect on files that include it.

Example (Godbolt)

Make a pragma.feature file in your source folder. List feature names/editions in the file. These features get picked up by every file in the folder.

This sounds like a terrible idea to me. Not only the compiler has to be aware of a file system entity (and file system, for that matter), but the language used in source files may change if files get moved.

baxter bloomberg 01

Who needs standards anyway, right?

baxter bloomberg 02

baxter bloomberg 04

Example of interface (Godbolt)

This looks cool, but it' not C++.

baxter bloomberg 05

There is a Circle feature for those who really dislike angle brackets, apparently.

Viktor Zverovich enters the chat:

baxter bloomberg 03

This provides a glimpse into Sean’s plan:

baxter bloomberg 06

I’m not convinced, but I’m a nobody – big firms like Bloomberg will surely be interested?

Sigh. If only Circle were open-sourced. Without that, betting on it is just too much risk, IMHO.

CppCast 383: Safe, Borrow-Checked, C++

https://cppcast.com/safe-borrow-checked-cpp/

Any news on Safe C++?

Reddit

CrowdStrike and C++

Sean Baxter enters the chat

Three Cool Things in C++26: Safety, Reflection & std::execution - Herb Sutter - C++ on Sea 2025

https://www.youtube.com/watch?v=kKbT0Vg3ISw

  • Safety
    • Erroneous behaviour
    • Stdlib hardening
    • Trivial relocation
  • Reflection
  • std::execution

Reddit

The Joy of C++26 Contracts - Myths, Misconceptions & Defensive Programming - Herb Sutter

https://www.youtube.com/watch?v=oitYvDe4nps

Known pitfalls in C++26 Contracts - Ran Regev

https://www.youtube.com/watch?v=tzXu5KZGMJk

Reddit

ran regev contract pitfalls 0001

How often do you create memory leak or segfault bugs with modern C++?

Reddit

Memory leaks - pretty much never. RAII takes care of those way too well for them to happen. The only time I may make them is if I have a resource that I simply don’t know I have to cleanup. Segfaults - I do sometimes make them, particularly during development. They are much more likely when I interface with very low level code (e.g. OS APIs or other low-level libraries), which tends to have many pointers and/or poor type safety. In high level code I make them much less commonly. Overall, I personally don’t find memory management in C++ to be too troublesome.

ACCU 2025 trip report, now with AI!

https://mropert.github.io/2025/04/10/accu_2025/

C++ Linkers and the One Definition Rule - Roger Orr - ACCU 2024

https://www.youtube.com/watch?v=HakSW8wIH8A

Linkers, Loaders and Shared Libraries in Windows, Linux, and C++ - Ofek Shilon - CppCon 2023

https://www.youtube.com/watch?v=_enXuIxuNV4

The existential threat against C++ and where to go from here - Helge Penne - NDC TechTown 2024

https://www.youtube.com/watch?v=gG4BJ23BFBE

TL;DR: Doom and gloom, there’s no hope to make C++ safe, just use Rust, which somehow is a drop-in replacement.

Ah, he’s from Thales. They had a C++/Rust job listing open recently, for working with secure communication. Wouldn’t be surprised if Thales internationally were generally moving towards Rust.

i’ve spent over three years each using C, then Rust, and then returning to C. Initially, i believed that borrow checking (and Rust as a whole) was a perfect solution. However, the more complex tasks i encountered, the more i realized that "memory safety" is an ideal that doesn’t fully exist in practice. <…​> Here’s the real challenge: proving that an unsafe block in Rust is both safe and sound is often more difficult than using raw pointers correctly in C or C++.

SwedenCpp Video List

https://www.swedencpp.se/videos

Why Nobody is Using C++ Modules

Henrique Bucher (please leave Substack!)

See also: Reddit

See also: Are We Modules Yet?

C++ package managers

Posted by Tomasz Wisniewski.

Daniel Lemire’s C++20 and C++23 snippets

https://lemire.me/blog/2024/11/02/having-fun-with-modern-c/

Falsehoods programmers believe about undefined behavior

Predrag Gruevski

The moment your program contains UB, all bets are off.

Even if it’s just one little UB.

Even if it’s never executed.

Even if you don’t know it’s there at all.

Thinking of using this next time when I have to prove that my UB fix is actually necessary.

Arithmetic Types in C++

C++ features banned in Chromium

HN thread

Boost: good or bad?

From Reddit:

Annoyed with Overuse of Boost in C++ Discussions

For instance, I was recently exploring Interprocess, only to find out I needed Boost.Date, which led me to implement it myself rather than dealing with the extra dependency.

Ah yes, a date library, famously easy to implement. (OK, they used a std::chrono wrapper, but still.)

And in your lack of experience, you committed a cardinal sin of programming. NEVER write your own datetime implementation unless you are prepared to dedicate a team to maintain it. Time zones are impossible, leap seconds will screw you, and numerous other pitfalls await. It’s almost always a terrible idea. Use a library that gets tons of real world use and debugging.

Boost is now modular you don’t need to build the full Boost Set of libraries + with vcpkg it is straightforward : I don’t understand why people try to reimplement sub parts of Boost in worse way. Sometime you can find better libraries than the Boost ones and that perfect, but imo Boost is the first to be tried.

We here use boost extensively, both server and embedded. Honestly I don’t know what all the fuss is about. It’s excellent code, well maintained by top folks in the C++ world. If you don’t like it, don’t use it. But don’t whine when other people do.

Annoyed with FUD surrounding Boost in C++ discussions

Alternatives to Boost

https://www.reddit.com/r/cpp/comments/1cpwyqj/whats_your_favorite_boost_alternative/

The Beman Project

Are We Modules Yet?

https://arewemodulesyet.org/

The C++20 Naughty and Nice List for Game Devs

Jeremy Ong

Discussions: HN, Lobsters

Learn Modern C++

A self-study C++20 course by Richard Spencer

GitHub

Lambdas in C++23

argparse 2.9 released

Stronk - a strong type and unit library

Reddit

New C++23 features I’m excited about, by Tomasz Wisniewski

Article

New usability improvements in GCC15

Revisiting Turbo C++

See also: The IDEs we had 30 years ago…​ and we lost, discussed on HN and Lobsters

turbo c 3050

A visual history of Visual C++

Article

msvc1

A Year of C++ Improvements in Visual Studio, VS Code, and vcpkg

Sy Brand, Microsoft

Book: C++ Initialization Story, by Bartłomiej Filipek

Blog post

See also: I HAVE NO CONSTRUCTOR, AND I MUST INITIALIZE, by Evan Girardin (Nice website banner, strong PDP-11 vibes). Discussion on HN.

Speeding up C++ build times

Blender forum: Speeding up C++ builds

Article

Working With Jumbo/Unity Builds (Single Translation Unit)

https://austinmorlan.com/posts/unity_jumbo_build/ by Austin Morlan

Figma

Subspace

Accidentally hiding base virtual functions

#include <iostream>

struct B
{
    virtual ~B() = default;
    virtual void foo() { std::cout << "B::foo()\n"; }
    virtual void foo(int) { std::cout << "B::foo(int)\n"; }
};

struct D1 : B
{
    void foo() override { std::cout << "I::foo()\n"; }
    // ^ MSVC warning 4266: no override for foo(int); function is hidden
};

struct D2 final : D1
{
    void foo() override { std::cout << "D::foo()\n"; }
    void foo(int) override { std::cout << "D::foo(int)\n"; }
};

int main(int /*argc*/, char** /*argv*/)
{
    B b;
    b.foo();
    b.foo(0);

    D1 i;
    i.foo();
    i.foo(0);    // Does not compile: base function is hidden
    i.B::foo(0); // Call base version

    D2 d;
    d.foo();
    d.foo(0);

    return 0;
}

Mastodon: preventing implicit conversions

https://mastodon.social/@ohunt/112294336934673348

Oliver Hunt:

I was today years old when I discovered you can stop implicit bool→int conversion in APIs where it causes problems by doing

int foo(int) {...}
int foo(bool) = delete;

Despite knowing this is a valid syntax it never occurred to me you could use it this way, and I did not realize you can do this for free functions O_o

ppstep Interactive Macro Debugger

https://github.com/notfoundry/ppstep

If you need a macro debugger, maybe reconsider your approach and step back?

On harmful overuse of std::move

Raymond Chen

Mastodon: Debugging

https://octodon.social/@splitbrain/112086905723468442

I really think debugging should be taught in school. Not for any programming language. Kids should learn how to systematically approach a problem, gather diagnostic, follow cause and effect and how to communicate the problem to others. Regardless if this is computer stuff, plumbing or social sciences.

Andreas Gohr https://octodon.social/@splitbrain

Bluesky

AI company: we trained this dog to talk. It doesn’t actually understand language, but it kinda sounds like it’s having a conversation by mimicking the sound of human speech.

CEO: awesome, I’ve fired my entire staff, how quickly can it start diagnosing medical disorders

Funky Dynamite @sweavart.bsky.social

Slop

https://simonwillison.net/2024/May/8/slop/

Remote workers

devopscats via Mastodon: https://toot.cat/@devopscats/112566801377839795

Behind every remote worker is a cat that hasn’t signed an NDA and will sell all the secrets for a piece of sashimi.

remote cat

Quote

https://mastodon.social/@programming_quotes/112572400857683147

One of the best programming skills you can have is knowing when to walk away for awhile.

Oscar Godson