Clice v1.0 Released: Welcome to Modern C++
A newly released C++ language server, Clice v1.0, is drawing interest for its architectural improvements over clangd, but users highlight persistent performance and stability challenges inherent in Clang-based tooling and the C++ language’s complexity. Commenters broaden the conversation to the evolving notion of “modern C++,” debating whether newer standards and features actually improve safety, readability, and maintainability or simply encourage fashion-driven code. The project’s reflective, somewhat melancholy conclusion about the future of human-written code in an era of AI-generated software also prompts concerns about the long-term value of deeply engineered tools versus flashy, short-lived AI outputs.
Performance and architecture of Clice vs clangd
- Several commenters complain that clang-based indexers (clangd, ccls, and thus Clice) are orders of magnitude slower than older non-clang indexers (Eclipse CDT, old Qt Creator).
- One person notes Clice is architecturally different (coroutines, multiprocess design) and shouldn’t be assumed as just a “derivative,” but others argue the core bottleneck is still clang’s translation unit recompilation.
- Real-world anecdotes: indexing very large codebases (e.g., tens of thousands of files, Unreal Engine–scale) can take many hours and huge RAM; Clice appears even slower than clangd in at least one test.
- Some accept the slowness as the price for precise, template- and modern-C++–aware analysis; older indexers were seen as less accurate but much faster.
Crashes, incomplete code, and C++ complexity
- Both clangd and Clice can crash on the same snippets because they share the clang frontend.
- Explanation given: C++ is extremely complex, especially with templates and incomplete/half-written code in an IDE; relatively few people test compilers on such inputs.
- One commenter claims C++’s grammar effectively requires Turing-complete parsing, implying unavoidable hangs/crashes; another strongly disputes this, calling it theoretical and attributing failures to fixable compiler bugs with practical limits.
“Modern C++” as a concept
- “Modern C++” is seen as shorthand for post‑C++11 (often explicitly C++20/23), but opinions diverge.
- Some find newer features (coroutines, concepts, constexpr, filesystem, format, optional/variant, string_view/span, etc.) make code more expressive, safer, and faster with no runtime cost.
- Others feel the culture around “modern” encourages using new features for their own sake, harming readability and robustness; they prefer simpler C++98/11 styles or “C with classes.”
- There’s recognition that idiomatic C++98, C++11, and C++20 now look like distinct dialects.
string_view, auto, and API design pitfalls
- Advocates praise string_view/span for avoiding hidden allocations and accepting multiple string/array types.
- Critics report real bugs from overuse: lifetime issues (e.g., string_view captured and used after original string dies), confusion amplified by heavy use of
auto, and misuse where code immediately converts back to std::string. - Consensus leans toward: these tools are powerful but easy to misuse; “can improve readability” does not mean “always do so.”
AI, agentic coding, and project meaning
- Some readers are struck by the melancholic conclusion that AI-generated systems may render such multi‑year efforts less “meaningful.”
- Pushback notes that humans still need good language servers to read and understand code, including AI-generated code; Clice is seen as valuable for that and as a learning resource.
- Another commenter criticizes hyped claims of LLMs “rewriting compilers,” arguing such outputs usually fail on real workloads and that optimizing for flashy demos undermines serious software craft.
Tooling choices and meta‑discussion
- Bazel choice over CMake is briefly justified as a speed/correctness tradeoff, with some mild questioning since CMake is the de facto standard.
- Repository’s extremely verbose, AI-style commit messages are widely viewed as “vibe smell” and an anti-pattern; several argue real design decisions belong in requirements/specs/ADRs, not bloated commits.