Mission Accomplished

As ever, I haven’t written an editorial. Like many, I was watching the Artemis II trip around the far side of the moon with fascination. ¹ I just missed out on the first moon landing – which possibly gives away my age. None of this is a proper excuse for no editorial. As ever, guest editors are welcome: do get in touch.

I think the trip to the moon was amazing. The number of things that needed planning was mind blowing. And the new, never before seen perspective of the far side of the moon was exciting. Would there be new craters? Clangers? [Wikipedia-1]. I presume many people had a sense of trepidation too. Previous trips to space have gone wrong. “Houston, we’ve had a problem…” springs to mind. When things go wrong, we have an opportunity to learn though. So even a failure can be useful.

What have missions to the moon got to do with anything? Well, I find technical things in general interesting. Most programmers have a similar mindset. Whether that means taking toys to pieces as a child, to find out what’s inside, or typing in code and tweaking it, maybe to get extra lives in a game, most of us have explored things some other people might just take for granted. Understanding how something works is satisfying. An “Aha, got it” moment can mean you can step back and muse rather than keep digging, enjoying the satisfaction of a job well done Mission accomplished, right?

I note that ‘Mission’ means send out or ‘to send abroad’ [etymonline], or release. Think missionary. And, people who write software do usually release software. Rephrasing ‘a release coming up’ as a ‘mission coming up’ might give it a sense of excitement, rather than dread! Mind you, excitement might not be what you’re after either. Many places avoid ‘big bang’ (an unfortunate phrase) release, doing small, incremental steps instead. Either way, once you release a new version of software, you no doubt watch it for a long while afterwards to check everything is running as expected. The release isn’t the end of the mission.

Some things do have a definite end point, though. For example, a clasp on my favourite necklace broke recently. I managed to acquire a new one and fixed it. Go me: hardware engineering, for a change. Fixing things in software is a different matter. Maybe you fix one bug and another pops up somewhere else. Or someone uses the new feature and notes it isn’t precisely what was needed. A woman’s work is never done, right [Wiktionary]? I went to the Agile Yorkshire meetup [Agile] last night and the first speaker mentioned the book The infinite game by Simon Sinek. I’ve not read it, but I’m told it has a focus on business strategy, and asks the question “Are you playing the finite game or the infinite game?” I assume this is partly about being prepared to keep innovating and learning. If you are ‘stuck’ in an infinite process, it’s useful to pause and reflect. Give yourself a moment to experience the joy of an achievement unlocked, even if the mission isn’t over.

Perhaps you’re not playing an infinite game. I mentioned fixing my necklace. That was straightforward. I have ‘finished’ other things, too. For example, I recently finished my third book. Relax and enjoy, right? I forced myself to do that, because I could see errata arriving. There are several I need to go through. It’s astonishing how many typos and similar always sneak through. When you create something, there are aftershocks. Feedback might be a mixture of positive and negative. Books have errata, software has bugs. Rocket launches have issues. Artemis 2 followed Artemis 1, which was a successful ‘unmanned’ exploration. Artemis 2 had some initial problems. NASA reported a “helium flow issue to the interim cryogenic propulsion stage” [Warner26] during a dry run (described as a wet dress rehearsal – words, eh?). They had to roll back the rocket (literally) and fix the problem. Further missions are planned. Their website lists three more, leading up to building a lunar base for further exploration. Where will it end? In theory, they are trying to get to Mars. We’ll see. If that does happen, I am sure that won’t be the end of matters.

Things are often never ending. I have a hand written TODO list. Ticking something off is satisfying, but usually when I complete one thing, I end up with two more to do. My mission accomplished point is when the paper is full: it’s time to get a new piece and start over. I then get the chance to abandon some tasks. Or realise I finished a few and tick them off on principle too. I do use a Trello board for some projects. The trouble is I can add a LOT of tasks to that. Somehow the physical constraint of a fixed sized piece of paper helps limit my ambitions to something manageable. Once upon a time, a little while ago, I was working as a research assistant. My supervisor booked a high-tech meeting room for the team, which had an electronic whiteboard. We could then save the board and email around the team. Great, right? The trouble was we added to it each time, so a large amount of the meeting was spent trying to scroll far enough to find where we were writing last time. The thing about infinite space is it’s very large. I guess the whiteboard wasn’t really infinite, but it was very difficult to find anything.

A limited list of things to do is useful. My list encompasses household chores, as well as work related items. I have started sneaking bucket-list ideas on too – experiences I’d like to have before it’s too late. I’m going to run out of paper again, real soon now. It might be better to have lists constrained to specific areas. New standards for C++ might seem a bit like a rolling TODO list, but they are grouped in various ways. There are bug reports as well as new ideas or proposals. ISOCpp gives a good overview of the process [ISO]. If you’ve joined ACCU, you will have seen the C++ standard report in each edition of the member’s magazine CVu. The most recent CVu covered C++26 [McMonagle26]. C++26 has been worked on for a while and is now complete. This means we’ll see a new International Standard document, once ‘editorial’ work has been done (fixing typos, I presume, don’t @ me!). We’ll then watch compilers try to catch up.

So, what’s in C++26? Herb Sutter calls out his “Fab Four Features” [Sutter26a]. These are reflection, dealing with some UB, via erroneous behavior for reading uninitialised variables and library hardening, contracts and std::execution. His blog mentions the abstract for a previous CppCon keynote, quoting, “We’ll need the next decade to discover what this rocket can do.” Everyone is distracted by rockets! I suspect C++ won’t go to Mars. Yet. There’s more to C++26 than just these four features. John McMonagle’s CVu write up, from just before the Croydon meeting, covers SIMD-friendly changes to random number generation, hazard pointers, and constexpr virtual inheritance. Which are your fab four features? I’m glad we have a reflection article in this edition. Maybe you will be inspired to write about one of the new features you have been trying out.

Of course, C++26 isn’t all about big new features. There are some small, but useful, changes too. I don’t have a full list, but one that’s crossed my radar is changes to structured bindings. There are several but now structured bindings can introduce a pack. You have probably come across parameter packs before, and this extends the idea. Sandor Dargo wrote a blog giving details [Dargo26], so I’ll use some of his examples.

Given a function std::tuple<X, Y, Z> f();, you could already say auto [x,y,z]=f();, provided you were using a new-enough version of C++. With the new pack feature, you can say auto [x, ...rest] = f();

That way, you can just concentrate on the first item. The pack can also refer to the last element and so on. You can also use pack to write neater code. Sandor gives an example for calculating the dot product:

  template <class P, class Q>
  auto dot_product(P p, Q q) {
    // no indirection!
    auto&& [...p_elems] = p;
    auto&& [...q_elems] = q;
    return (... + (p_elems * q_elems));
  }

Previous C++ standards required nested std::apply in a couple of loops or use of potentially hard to read std::index_sequence calls. Reddit suggests Barry Revzin and Jonathan Wakely were involved, but Jonathan claimed Barry did all the work [Reddit-1]! That’s just one small feature. Fortunately, CppReference is back up and running, so you can check the site to find out more C++26 features [cppreference]. If you missed what happened, the site had been in maintenance mode for a worryingly long time, partly due to sabotage from people allegedly making changes to say many C++ features had been superseded by Rust. Fortunately, the standard C++ foundation stepped in and helped, so it’s back up and running [Sutter26b]. I am relieved: CppReference had been an invaluable place to look things up.

A new standard is exciting, and many people are trying out new features or giving conferences talks about them. That’s great, but in the ‘real world’, almost no companies will immediately start using newer compilers. Jens Weller has run a few surveys over the years, finding out what people actually use at work. (Other data is available too, that just sprung to mind first.) Though some people are using C++20 (and perhaps C++23), many are stuck on C++11 or C++17. [Weller22]. If you are in that situation, fair enough. Maybe demand some training time at work to try out new features, or ask if your employer will pay for a conference ticket for you. Or try out a feature on your own time, and write it up for us.

I wonder how smooth any upgrades will be. I recall much pain moving to newer versions of boost or more modern compilers. I frequently had to plough through a huge number of errors and warnings, but when the team finally got to the end, we’d often fixed a few bugs or potential security flaws. A recent discussion on accu-general explored what to look out for when porting from C++17 to C++20 (one more data point for Jens). The original posted said they knew that the spaceship operator might cause problems, comparing pointers rather than the strings they point to [Reddit-2], but was there anything else to look out for. Jonathan Wakely replied, “Yes, lots!” Go check out the thread: I’ll try to persuade him to write things up for us. GCC does provide a list of things to watch out for [GCC], and Thomas Köppe wrote a more general list in 2020 [Köppe20], which has a section (‘New core language features with global applicability’) that states “These are features that may happen to you without your knowledge or consent.” This includes details on the spaceship operator and default comparisons. No doubt, we’ll get lists of things to watch out for in C++26 soon. Herb Sutter’s blog did suggest a “whole category of potential vulnerabilities disappears in C++26, just by recompiling your code as C++26”. Give it a go and report back.

So, mission accomplished? Maybe not. Each ending is the start of new things. To misquote JFK, we choose to upgrade C++, not because it’s easy, but because it includes hardening, and makes C++ safer. Let’s accept challenges, and terraform Mars. Or just write an article or two. Over to you.

References

[Agile] Agile Yorkshire: https://agileyorkshire.org/

[cppreference] C++26 available at https://cppreference.com/cpp/26

[Dargo26] Sandor Dargo, ‘C++26: Structured Bindings can introduce a Pack’, updated on his blog 28 April 2026 and available at http://sandordargo.com/blog/2026/04/22/cpp26-structured-bindings-packs

[etymonline] ‘mission’: https://www.etymonline.com/word/mission

[GCC] Porting to GCC 16: https://gcc.gnu.org/gcc-16/porting_to.html#cpp

[ISO] C++ Standardization: https://isocpp.org/std

[Köppe20] Thomas Köppe20, ‘Changes between C++17 and C++20 DIS’, published 2 March 2020, available at http://open-std.org/jtc1/sc22/wg21/docs/papers/2020/p2131r0.html

[McMonagle26] John McMonagle, ‘Standard Report’ (regular feature), most recently in CVu 38.1 and available to members only at https://accu.org/journals/cvu/38/1/mcmonagle/

[Reddit-1] ‘C++26: Structured Bindings can introduce a Pack’, discussion available at https://www.reddit.com/r/cpp/comments/1su6ipi/c26_structured_bindings_can_introduce_a_pack/

[Reddit-2] ‘The spacesship operator silently broke my code’, discussion available at https://www.reddit.com/r/cpp/comments/ra5cpy/the_spacesship_operator_silently_broke_my_code/

[Sutter26a] Herb Sutter, ‘C++26 is done! – Trip report: March 2026 ISO C++ standards meeting (London Croydon, UK)’, posted on his blog Sutter’s Mill on 29 March 2026, available at https://herbsutter.com/2026/03/29/c26-is-done-trip-report-march-2026-iso-c-standards-meeting-london-croydon-uk/

[Sutter26b] Herb Sutter, ‘Announcement: cppreference.com update’ posted 14 April 2026 at https://isocpp.org/blog/2026/04/announcement-cppreference.com-update

[Warner26] Cheryl Warner ‘NASA Strengthens Artemis: Adds Mission, Refines Overall Architecture’, NASA, posted 3 March 2026, available at https://www.nasa.gov/directorates/esdmd/nasa-strengthens-artemis-adds-mission-refines-overall-architecture/

[Weller22] Jens Weller, ‘If your pool runs dry, maybe fix your pipeline?’ posted on Meeting C++ Newsletter, published 3 November 2022 at https://www.meetingcpp.com/blog/items/If-your-pool-runs-dry--maybe-fix-your-pipeline-.html

[Wikipedia-1] Clangers: https://en.wikipedia.org/wiki/Clangers

[Wikipedia-2] Far side of the moon (https://en.wikipedia.org/wiki/Far_side_of_the_Moon) and Dark side of the moon (https://en.wikipedia.org/wiki/The_Dark_Side_of_the_Moon)

[Wiktionary] ‘a woman’s work is never done’: https://en.wiktionary.org/wiki/a_woman%27s_work_is_never_done

Footnote

1. Thanks to the review team for pointing out this is different from the Dark Side of the Moon [Wikipedia-2].

Frances Buontempo has a BA in Maths + Philosophy, an MSc in Pure Maths and a PhD using AI and data mining. She’s written a book about machine learning called Genetic Algorithms and Machine Learning for Programmers, and one to help you catch up with C++ called Learn C++ by Example. She has been a programmer since the 90s, and learnt to program by reading the manual for her Dad’s BBC model B machine.