The ACCU Conference and C++ On Sea came together for the first ACCU On Sea in Folkestone, UK, in June 2026. The merger placed deep C++ language work and broader software-development practice on the same program.

That is more than a conference rename. It surfaces practical questions about what to validate when code is easy to generate, how to modernize systems that must keep running, and how much confidence to place in a feature that is still moving through standardization.

Using the sessions highlighted in the trip report, we can trace three decisions that matter in day-to-day C++ work.

The merger puts C++ language depth and software design in one program

According to the official ACCU On Sea introduction, the ACCU Conference began in 1997, while C++ On Sea had focused on C++ since 2019. The combined event keeps C++ at its center while also covering other languages, testing, and software design.

In 2026, workshops ran on June 15 and 16, followed by the main conference from June 17 through June 20. The four-day, five-track program included C++23 and C++26, reflection, Contracts, safety, asynchronous programming, performance, and code quality. It was neither a language-feature-only event nor a general software conference with C++ at the margins.

The trip report described a sold-out audience of roughly 400. The current 2027 sponsorship prospectus records 400 attendees in 2026, calls that the venue's comfortable maximum, and says the combined format will continue in 2027. The merger has therefore moved beyond a one-year experiment.

AI shifts the bottleneck from producing code to understanding and validating it

Andrei Alexandrescu's keynote, “The Next 20 Weeks of Systems Engineering,” started from an asymmetry: AI can produce large amounts of code, while inspection and validation remain difficult. The official session description places the emphasis on understanding system structure and behavior as complexity grows, not on maximizing generated output.

In practical terms, the ability to generate a patch is not the same as the ability to accept it. Reviewable scope, tests that pin down intent, and the ability to isolate a failure can matter sooner than raw generation speed.

The legacy-modernization talk discussed in Sándor Dargó's complete report gives this idea an operational shape. It combines deterministic static analysis with flexible but nondeterministic AI assistance, while making the scope smaller as a change becomes more complex or risky. Breaking a rewrite into local, mechanically verifiable changes makes AI productivity easier to connect to reviewability.

Legacy C++ benefits from localized change before techniques that reach into internals

The same report also covers a session that used explicit template instantiation to test private members in code that could not be changed. Section 13.9.1 of C++ Working Draft N4950 says that the usual access-checking rules do not apply to certain names in declarations of explicit instantiations and explicit specializations.

The technique has a basis in the language rules, but it does not remove coupling to private implementation details. A change to the target class can still break the test, and such a test serves a different purpose from verifying a public interface contract.

When the code is under your control, a dependency seam or a small public boundary should be considered first. For a third-party library or transitional code with no available seam, the technique can be contained in a narrow test adapter. That ordering matches the preceding lesson: modernize a running system through localized, explainable change.

P3097 connects a C++26 Contracts gap to the C++29 process

C++26 includes contract assertions, but pre and post cannot be attached to virtual functions. The ACCU On Sea session page explains that the committee did not reach agreement on their runtime-polymorphism semantics within the C++26 timeframe.

P3097 addresses that gap. P3097R3 distinguishes caller-facing assertions on the function selected statically by the call expression from callee-facing assertions on the final overrider selected by dynamic dispatch. Both sets are evaluated, and an overriding declaration's assertions remain independent instead of being inherited implicitly.

The relationship can be reduced to this conceptual example. It illustrates the P3097 model; it is not code that current C++26 accepts as written.

struct Base {
  virtual void process(int count)
    pre (count > 0);
};

struct Derived : Base {
  void process(int count) override
    pre (this->ready());

  bool ready() const;
};

A call to Derived::process through a Base& would distinguish the condition visible to the caller through Base from the condition on the Derived implementation that actually runs. Multiple inheritance and independently deployed libraries make this more than a matter of simply inheriting one condition.

The committee stage matters. P3097R3 records that on June 10, 2026, EWG reached consensus to forward P3097R2 to CWG for inclusion in C++29. That is meaningful progress, but it is not the same as final adoption into C++29 or completed compiler support.

ACCU On Sea 2026 leaves developers with an order for adoption decisions

The opening question now has a practical answer. ACCU On Sea 2026 does not portray C++ as a language that only accumulates features. It connects generating a change, keeping its scope small, validating its meaning through tests and review, and tracking a standards proposal at the correct stage.

A team can start by turning AI output into small, verifiable diffs. For standards work, separating proposal, working-group consensus, adoption into a working draft, and compiler implementation helps prevent expectations from running ahead of deployable reality.

That is also the practical meaning of the conference merger. It creates one forum where C++ language design and the constraints of evolving production systems can inform each other—and that is useful even to developers who were not in the room.

Source

• Title: Trip report: ACCU On Sea 2026 -- Sandor Dargo
• URL: https://isocpp.org//blog/2026/08/trip-report-accu-on-sea-2026-sandor-dargo