C++, modules, etc.

Everyone seems to be running to embrace Rust. I spent some time last summer learning the basics through Rustlings, and I enjoyed the ideas behind it - but it seems like Rust requires significant up-front design as part of managing memory ownership. I don't mind that: up front design is one of the key differences between "development" and "engineering". I worry that the structure of the design is so fundamental when using Rust, though, that it will be difficult to refactor and change the structure of the program as needed, leading to more rewrites. I don't have experience with large Rust codebases yet, so I don't know how real that concern is. It is pretty common for actual users to need something different than predicted users, and to need to do significant refactoring.

I continue to learn and play with C++. Most people I've spoken with disagree with this sentiment, but I still believe that C++ will evolve "safe enough" practices sooner than people will feasibly port away from it. By "Safe Enough" I mean that the rate of memory safety issues will go down to the point where it's no longer the most pressing problem in the code. Stroustrup and Sutter both have written posts about "safety profiles", and a lot of effort has gone into the C++ Core Guidelines. With modern C++, it is much easier to avoid pointer arithmetic, disable pass-by-value for classes, and avoid other gotchas. It's still harder than it needs to be, but I'm betting that the competitive pressure from Rust will light a fire under making this happen in the next few years. To add evolutionary pressure to C++ we need Rust to be successful now and ongoing.

In order to better understand modern C++, I like to do experiments and use new idioms in my open source code. Today's hacking time was spent testing C++ modules. Clang has supported a form of modules for a while, but as of June 12th, libc++ has marked the experimental module support as complete. So I wanted to try it! With C++23, hello world can look like this:

import std;

int
main()
{
    std::print("Hello, world\n!");
    return 0;
}        

(I just realized I could've done std::println. Oops!)

I love the idea of not having to think about STL includes, and how using C++ modules can help people "Include What You Use". So I followed the instructions on the libc++ website and it works! If you want to try it, my repository is set up to work well with GitHub Codespaces and will build an Ubuntu 24.04 container. You will need to install Homebrew, and install cmake from HEAD. Then install clang 19 from apt.llvm.org, making sure that you install libc++-19-dev and clang-tools-19. I used VSCode in my Codespace, so it should work with the usual CMake workflows: Configure, Scan for kits, and then build it.

I'm looking forward to the CMake 3.30 and the LLVM-19 releases!

(obDisclosure: I work for Google, but I am not speaking for them in this post)