ClickHouse 26.8 LTS Arrives with 49 New Features and 21 Breaking Changes

·1 views

ClickHouse has released version 26.8 as its newest Long-Term Support build, featuring 49 new features, 127 performance improvements, and 556 bug fixes. The release also introduces 21 backward-incompatible changes and alters the default values of around 30 settings, making pre-upgrade testing critical. A notable breaking change involves max_insert_threads, which now defaults to automatic CPU-based parallelism instead of single-threaded behavior, potentially affecting insert order and parts count. UPDATE patch parts have also moved to a new v2 on-disk format with an improved merging algorithm, requiring a rolling-upgrade pin for replicated clusters. As of late August 2026, the release had been announced but the upstream changelog was still marked as in progress, so users are advised to verify release status before scheduling an upgrade.

Read the full story at DEV Community

This is an AI-generated summary. ShortSingh links to the original source for the complete article.

Discussion (0)

48-Hour AI Stress Test Reveals How Free Models Drift Over Repeated Tasks

A developer ran the same support-ticket classification task against a free AI model every hour for 48 hours to test behavioral consistency rather than raw accuracy. The experiment used ten support tickets and three labels, with each ticket appearing roughly twelve times across the test period. Around the 22-hour mark, the model began misclassifying a ticket and reinforcing its own errors because the prompt fed it recent outputs as memory, causing it to trust stale context over the actual input. Response hashing proved critical, flagging format changes and anomalies that a lenient label parser had silently masked as successful runs. The author concluded that long-running automation depends more on output stability and honest logging than on benchmark performance scores.

0 comments Read more at DEV Community

ProgrammingDEV Community ·

Golden-File Refactor Loop Offers a Safer Way to Modernize Legacy Code

A software development technique called the 'golden-file refactor loop' proposes a structured, four-step method—record, verify, move, commit—to safely refactor complex legacy code without fully understanding it. Instead of writing unit tests that require knowing a function's intent, developers capture actual runtime behavior, including return values and side effects, into snapshot files that serve as a behavioral baseline. Each refactoring move is kept deliberately small, limited to a single file and a bounded number of changed lines, with the snapshot re-verified after every step. AI models can propose individual code changes, but the golden file—not model confidence—determines whether a change is accepted. The approach is positioned as faster and more honest than guessing a messy function's contract upfront, particularly for large legacy codebases.

0 comments Read more at DEV Community

ProgrammingDEV Community ·

AI Writes the Docs, But Humans Must Own the Decisions

As AI-generated documentation becomes common, the bottleneck in the process shifts from writing to reviewing, exposing weaknesses in traditional review habits built for scarce text. Teams often fall into two failure patterns: merging long documents because reading felt like work, or editing minor style issues while substantive errors slip through. A proposed four-step pipeline addresses this by using a YAML ownership file to classify each documentation section by tier — freely drafted, human-verified, or fully human-owned. The AI model is instructed to draft only permitted sections and flag uncertain claims with an @UNRESOLVED marker, making hallucination risks visible and actionable. This approach reframes the human role from prose editor to decision-maker, with merge gates enforcing accountability at each ownership boundary.

0 comments Read more at DEV Community

ProgrammingDEV Community ·

Why a Production AI Agent Refusing 96 Answers Was Actually a Success

A senior ML engineer's production support agent refused to answer 96 questions in a benchmark test, which the product team initially flagged as failures. Engineering review found that in 96% of those cases, the model correctly detected insufficient or contradictory retrieved context and chose to withhold a response rather than guess. This behavior reflects a design philosophy called 'hard failure modes,' where an AI agent explicitly signals inability to answer instead of generating a plausible but potentially false response. The approach borrows from systems programming principles, treating 'I don't know' as a legitimate output type rather than an error to suppress. Architects are increasingly building multi-step verification pipelines — using structural and semantic checks — to prevent confident hallucinations in high-stakes applications like financial auditing, code generation, and compliance.

0 comments Read more at DEV Community