# Sandor Dargo's Blog

Sandor Dargo writes about about C++, software development, books and stoic philosophy applied to software craftsmanship

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## Every Craft That Moved Before: What Photography, Compilers, and Looms Teach Us About AI

DevFeed: [Every Craft That Moved Before: What Photography, Compilers, and Looms Teach Us About AI](<https://devfeed.tech/articles/every-craft-that-moved-before-what-photography-compilers-and-looms-teach-us-about-ai-129126.md>)

Original publisher: [Read original article](<https://www.sandordargo.com/blog/2026/11/11/every-craft-that-moved-before>)

Author: Sandor Dargo

Published: 2026-11-10T23:00:00Z

Content type: opinion

Language: en

Sources: [Sandor Dargo's Blog](<https://devfeed.tech/sources/sandor-dargo-s-blog.md>)

Topics: [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [Compilers and Linkers](<https://devfeed.tech/topics/compilers-and-linkers.md>), [Programming language](<https://devfeed.tech/topics/programming-language.md>)

Tags: [age-of-ai](<https://devfeed.tech/tags/age-of-ai.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-coding-assistants](<https://devfeed.tech/tags/ai-coding-assistants.md>), [ai-generated-code](<https://devfeed.tech/tags/ai-generated-code.md>), [algorithms](<https://devfeed.tech/tags/algorithms.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [assembly](<https://devfeed.tech/tags/assembly.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [code](<https://devfeed.tech/tags/code.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [compilers](<https://devfeed.tech/tags/compilers.md>), [computing](<https://devfeed.tech/tags/computing.md>), [craft](<https://devfeed.tech/tags/craft.md>), [data-structures](<https://devfeed.tech/tags/data-structures.md>), [dev](<https://devfeed.tech/tags/dev.md>), [machine](<https://devfeed.tech/tags/machine.md>), [photography](<https://devfeed.tech/tags/photography.md>), [programming](<https://devfeed.tech/tags/programming.md>), [talk](<https://devfeed.tech/tags/talk.md>)

### AI overview

The article argues that automation repeatedly shifts a craft's center of skill rather than simply ending it: photography reduced demand for realistic portrait work while painting explored other forms; FORTRAN compilers displaced hand-written machine code and freed programmers to focus on algorithms and architecture; mechanized weaving and automobiles similarly moved work toward operating and designing larger systems. People whose skills sit directly in the automated layer can suffer real losses, and the article treats resistance and grief as understandable. It sees AI coding as another shift, but says its destination is less clear than the move from assembly to FORTRAN: prompting and reviewing generated code have not yet formed a settled craft. The author suggests this uncertain period may precede a new layer of work centered on human judgment, taste, and vision.

### Source excerpt

Every time a machine learns a new trick, skilled people panic. And every time, they say some version of the same thing: this is different. This time it's really the end. They're always right that it's different. And they're almost always wrong that it's the end. I've been preparing a talk for Meeting C++ about what happened to the joy of programming in the age of AI. As part of that work, I w...

## C++26 Ranges: Parallel Algorithms and Safer Filters

DevFeed: [C++26 Ranges: Parallel Algorithms and Safer Filters](<https://devfeed.tech/articles/c-26-ranges-parallel-algorithms-and-safer-filters-105777.md>)

Original publisher: [Read original article](<https://www.sandordargo.com/blog/2026/10/28/cpp26-ranges-part-3-parallel-and-safety>)

Author: Sandor Dargo

Published: 2026-10-27T23:00:00Z

Content type: article

Language: en

Sources: [Sandor Dargo's Blog](<https://devfeed.tech/sources/sandor-dargo-s-blog.md>)

Topics: [stl](<https://devfeed.tech/topics/stl.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [Algorithms](<https://devfeed.tech/topics/algorithms.md>)

Tags: [algorithms](<https://devfeed.tech/tags/algorithms.md>), [c-plus-plus-26](<https://devfeed.tech/tags/c-plus-plus-26.md>), [dev](<https://devfeed.tech/tags/dev.md>), [parallel](<https://devfeed.tech/tags/parallel.md>), [parallelism](<https://devfeed.tech/tags/parallelism.md>), [policies](<https://devfeed.tech/tags/policies.md>)

### AI overview

C++26 adds execution policies to over 50 non-numeric range algorithms, letting ranges use `seq`, `par`, `par_unseq`, or `unseq` without converting pipelines to iterator pairs. Parallel overloads require a range that is both random-access and sized, so filtered or unbounded ranges cannot be passed directly; projections are supported, and outputs must be bounded ranges. Callables must be copy-constructible, `for_each` returns an iterator rather than its function object, and constexpr support is absent. P3725 also changes `filter_view`: const iteration is available for input ranges, and modifying an element through a filter iterator is defined if the predicate is not re-evaluated on it. The article recommends `views::to_input` before a filter in hazardous compositions; this can make `reverse` fail at compile time and enable const iteration.

### Source excerpt

In part 1 we looked at the new views C++26 adds, and in part 2 we covered the infrastructure improvements. This final part is about the biggest gap in C++20 ranges: you couldn't run them in parallel. C++17 added execution policies to the classic std:: algorithms, but C++20 ranges never got them. If you wanted parallelism, you had to decompose your ranges pipeline back into iterator pairs. C++26...

## C++26 Ranges: Better Infrastructure

DevFeed: [C++26 Ranges: Better Infrastructure](<https://devfeed.tech/articles/c-26-ranges-better-infrastructure-93115.md>)

Original publisher: [Read original article](<https://www.sandordargo.com/blog/2026/10/21/cpp26-ranges-part-2-infrastructure>)

Author: Sandor Dargo

Published: 2026-10-20T22:00:00Z

Content type: article

Language: en

Sources: [Sandor Dargo's Blog](<https://devfeed.tech/sources/sandor-dargo-s-blog.md>)

Topics: [Algorithms](<https://devfeed.tech/topics/algorithms.md>), [vectorization techniques](<https://devfeed.tech/topics/vectorization-techniques.md>)

Tags: [algorithms](<https://devfeed.tech/tags/algorithms.md>), [c-plus-plus-26](<https://devfeed.tech/tags/c-plus-plus-26.md>), [containers](<https://devfeed.tech/tags/containers.md>), [dev](<https://devfeed.tech/tags/dev.md>), [generation](<https://devfeed.tech/tags/generation.md>), [hint](<https://devfeed.tech/tags/hint.md>), [infrastructure](<https://devfeed.tech/tags/infrastructure.md>), [range](<https://devfeed.tech/tags/range.md>)

### AI overview

The excerpt describes three C++26 changes aimed at making ranges more practical. `approximately_sized_range` and `ranges::reserve_hint` let containers such as `std::vector` reserve using an O(1) estimate when exact size is unknown; predictable views can propagate hints, while unpredictable views such as `filter` do not. `std::ranges::generate_random` adds range and iterator-pair interfaces, checking for a batch-generation customization on the engine or distribution and otherwise generating element by element. The excerpt says no standard engine currently provides that customization. Finally, list-initialization defaults algorithm value types so calls such as `std::find` can accept braced values; ranges algorithms account for projections, while `replace_copy` and numeric algorithms are excluded.

### Source excerpt

Not every ranges improvement is a shiny new view adaptor. Some of the most impactful C++26 changes are infrastructure: making containers work better with lazy ranges, bringing random number generation into the ranges world, and removing a long-standing ergonomic paper cut from algorithms. This post covers all three. approximately_sized_range and reserve_hint Here's a scenario that should bo...

## C++26 Ranges: Four New Views

DevFeed: [C++26 Ranges: Four New Views](<https://devfeed.tech/articles/c-26-ranges-four-new-views-86853.md>)

Original publisher: [Read original article](<https://www.sandordargo.com/blog/2026/10/14/cpp26-ranges-part-1-new-views>)

Author: Sandor Dargo

Published: 2026-10-13T22:00:00Z

Content type: article

Language: en

Sources: [Sandor Dargo's Blog](<https://devfeed.tech/sources/sandor-dargo-s-blog.md>)

Topics: [data type](<https://devfeed.tech/topics/data-type.md>)

Tags: [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [c-plus-plus-20](<https://devfeed.tech/tags/c-plus-plus-20.md>), [c-plus-plus-23](<https://devfeed.tech/tags/c-plus-plus-23.md>), [c-plus-plus-26](<https://devfeed.tech/tags/c-plus-plus-26.md>), [dev](<https://devfeed.tech/tags/dev.md>)

### AI overview

The article explains four C++26 ranges views: `views::concat` for lazy iteration across ranges, `views::to_input` to simplify iterator behavior and reduce work, `views::cache_latest` to avoid repeated transform evaluations, and `views::indices` for generating an index range. It also describes constraints and behavior of each view.

### Source excerpt

C++20 shipped a powerful ranges library, but the set of view adaptors had some obvious gaps. Want to get the output as a container? No luck. At least C++23 helped with that. Want to iterate over two vectors as one sequence? Write your own. Want to avoid redundant evaluations in a transform | filter pipeline? Write a workaround. Want a quick index sequence matching a range's size? Spell out iota...

## Using AI agents in C++ development: lessons from CppCon 2026

DevFeed: [Using AI agents in C++ development: lessons from CppCon 2026](<https://devfeed.tech/articles/c-and-ai-at-cppcon-we-have-to-use-agents-more-or-less-66460.md>)

Original publisher: [Read original article](<https://www.sandordargo.com/blog/2026/10/07/cpp-and-ai-at-cppcon>)

Author: Sandor Dargo

Published: 2026-10-06T22:00:00Z

Content type: opinion

Language: en

Sources: [Sandor Dargo's Blog](<https://devfeed.tech/sources/sandor-dargo-s-blog.md>)

Topics: [AI-assisted coding](<https://devfeed.tech/topics/ai-assisted-coding.md>), [Machine learning](<https://devfeed.tech/topics/machine-learning.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [cppcon](<https://devfeed.tech/tags/cppcon.md>), [dev](<https://devfeed.tech/tags/dev.md>), [llms](<https://devfeed.tech/tags/llms.md>)

### AI overview

Reflecting on AI talks at CppCon 2026, the author argues that software engineers should use AI agents for brainstorming, prototyping, and focused microtasks while preserving their own judgment and expertise. The article describes concerns including code quality erosion, increased review load, and burnout, and recommends separating planning, implementation, and review across agents, with extra caution for critical code.

### Source excerpt

A few weeks ago, I went to CppCon 2026. Unsurprisingly at a C++ conference this year, one of the most prevalent topics was AI and how we should use it -- better -- in our industry. There were ten talks mentioning AI or LLMs in their titles - excluding pre/post conference workshops: AI is UB with Better PR -- Matt Kulukundis, Andy Soffer C++ in an AI World -- Jody Hagins C++ in the Age of ...

## C++26 standardizes breakpoints and debugger detection

DevFeed: [C++26 standardizes breakpoints and debugger detection](<https://devfeed.tech/articles/c-26-62258.md>)

Original publisher: [Read original article](<https://www.sandordargo.com/blog/2026/09/30/cpp26-debugging>)

Author: Sandor Dargo

Published: 2026-09-29T22:00:00Z

Content type: article

Language: en

Sources: [Sandor Dargo's Blog](<https://devfeed.tech/sources/sandor-dargo-s-blog.md>)

Topics: [c/c++](<https://devfeed.tech/topics/c-c-plus-plus.md>), [x86](<https://devfeed.tech/topics/x86.md>), [gdb](<https://devfeed.tech/topics/gdb.md>)

Tags: [asm](<https://devfeed.tech/tags/asm.md>), [bare-metal](<https://devfeed.tech/tags/bare-metal.md>), [breakpoint](<https://devfeed.tech/tags/breakpoint.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [c-plus-plus-26](<https://devfeed.tech/tags/c-plus-plus-26.md>), [clang](<https://devfeed.tech/tags/clang.md>), [debugger](<https://devfeed.tech/tags/debugger.md>), [debugging](<https://devfeed.tech/tags/debugging.md>), [dev](<https://devfeed.tech/tags/dev.md>), [gcc](<https://devfeed.tech/tags/gcc.md>), [i386](<https://devfeed.tech/tags/i386.md>), [libstdc-plus-plus](<https://devfeed.tech/tags/libstdc-plus-plus.md>), [linux](<https://devfeed.tech/tags/linux.md>), [x86-64](<https://devfeed.tech/tags/x86-64.md>)

### AI overview

C++26 adds standardized functions for triggering breakpoints and checking whether a debugger is attached. The article explains their behavior, platform-specific implementation choices, and how replaceability supports freestanding environments where operating-system debugger detection may be unavailable.

### Source excerpt

If you've ever needed to hit a breakpoint programmatically in C++, you've probably written something like this: #if defined(_MSC_VER) __debugbreak(); #elif defined(__clang__) __builtin_debugtrap(); #elif defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__)) __asm__ volatile("int3"); #else raise(SIGTRAP); #endif Every major C++ project reinvents this wheel. B...

## Trip report: CppCon 2026

DevFeed: [Trip report: CppCon 2026](<https://devfeed.tech/articles/trip-report-cppcon-2026-58342.md>)

Original publisher: [Read original article](<https://www.sandordargo.com/blog/2026/09/23/trip-report-cppcon-2026>)

Author: Sandor Dargo

Published: 2026-09-22T22:00:00Z

Content type: opinion

Language: en

Sources: [Sandor Dargo's Blog](<https://devfeed.tech/sources/sandor-dargo-s-blog.md>)

Topics: [C++](<https://devfeed.tech/topics/c-plus-plus.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [books](<https://devfeed.tech/tags/books.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [conference](<https://devfeed.tech/tags/conference.md>), [contracts](<https://devfeed.tech/tags/contracts.md>), [cppcon](<https://devfeed.tech/tags/cppcon.md>), [talks](<https://devfeed.tech/tags/talks.md>), [trip-report](<https://devfeed.tech/tags/trip-report.md>)

### AI overview

A personal report from CppCon 2026 covering the author's conference attendance, talks, social connections, travel experiences, and favorite sessions on proposed C++29 contract extensions.

### Source excerpt

Last year I wrote that a dream came true by attending and speaking at CppCon. And here I was again! Someone is living the dream, apparently. 21 LinkedIn posts shared, 24 sessions attended, 3 talks given. Those are just numbers, though. The human connections are what make a conference special, and CppCon being the largest C++ conference, there is no shortage. If you just want to wind down with...

## C++26: Trivial infinite loops are no longer undefined behaviour

DevFeed: [C++26: Trivial infinite loops are no longer undefined behaviour](<https://devfeed.tech/articles/c-26-trivial-infinite-loops-are-no-longer-undefined-behaviour-53295.md>)

Original publisher: [Read original article](<https://www.sandordargo.com/blog/2026/09/16/cpp26-trivial-infinite-loops>)

Author: Sandor Dargo

Published: 2026-09-15T22:00:00Z

Content type: article

Language: en

Sources: [Sandor Dargo's Blog](<https://devfeed.tech/sources/sandor-dargo-s-blog.md>)

Topics: [C++](<https://devfeed.tech/topics/c-plus-plus.md>), [undefined\_behavior](<https://devfeed.tech/topics/undefined-behavior.md>), [Compiler](<https://devfeed.tech/topics/compiler.md>), [Optimization](<https://devfeed.tech/topics/optimization.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>)

Tags: [atomic](<https://devfeed.tech/tags/atomic.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [dev](<https://devfeed.tech/tags/dev.md>), [optimize](<https://devfeed.tech/tags/optimize.md>), [support](<https://devfeed.tech/tags/support.md>), [undefined-behaviour](<https://devfeed.tech/tags/undefined-behaviour.md>)

### AI overview

This article explains why side-effect-free infinite loops were undefined behavior in C++ before C++26, how compilers could optimize them away, and how proposal P2809R3 makes trivial infinite loops well-defined. It also discusses the differing C rules and the use of such loops as halt-on-error patterns in embedded and kernel code.

### Source excerpt

Let's start with a question! Is this program well-defined? int main() { while (true) ; } If you said yes, you'd be wrong -- at least before C++26. A while (true); loop with no side effects used to be undefined behaviour. Compilers were free to assume it terminates, and some -- Clang in particular -- would optimize it away entirely, with spectacular consequences: // https://godbolt....

## C++26: Module improvements

DevFeed: [C++26: Module improvements](<https://devfeed.tech/articles/c-26-module-improvements-53294.md>)

Original publisher: [Read original article](<https://www.sandordargo.com/blog/2026/09/09/cpp26-modules>)

Author: Sandor Dargo

Published: 2026-09-08T22:00:00Z

Content type: article

Language: en

Sources: [Sandor Dargo's Blog](<https://devfeed.tech/sources/sandor-dargo-s-blog.md>)

Topics: [C++](<https://devfeed.tech/topics/c-plus-plus.md>), [modules](<https://devfeed.tech/topics/modules.md>), [Build tool](<https://devfeed.tech/topics/build-tool.md>), [Unit testing](<https://devfeed.tech/topics/unit-testing.md>)

Tags: [build-system](<https://devfeed.tech/tags/build-system.md>), [build-tool](<https://devfeed.tech/tags/build-tool.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [dev](<https://devfeed.tech/tags/dev.md>), [improvements](<https://devfeed.tech/tags/improvements.md>), [modules](<https://devfeed.tech/tags/modules.md>), [unit-test](<https://devfeed.tech/tags/unit-test.md>)

### AI overview

This article explains three targeted C++26 changes intended to improve C++ modules. It focuses on removing macros from module declarations to simplify dependency discovery, allowing explicit attachment to the global module from a module unit for testing non-exported entities, and addressing additional module-related friction.

### Source excerpt

C++20 introduced modules as a - potential - fundamental shift in how we organize and consume C++ code. Sadly, the adoption has been slow -- build system support lagged, compiler implementations were incomplete and diverging, and some of the original design decisions created unnecessary friction. C++26 addresses some of these pain points with three targeted fixes. P3034R1: Module declarations ...

## C++ Concepts is now a Leanpub course

DevFeed: [C++ Concepts is now a Leanpub course](<https://devfeed.tech/articles/c-concepts-is-now-a-leanpub-course-53293.md>)

Original publisher: [Read original article](<https://www.sandordargo.com/blog/2026/09/04/cpp-concepts-course>)

Author: Sandor Dargo

Published: 2026-09-03T22:00:00Z

Content type: release

Language: en

Sources: [Sandor Dargo's Blog](<https://devfeed.tech/sources/sandor-dargo-s-blog.md>)

Topics: [C++](<https://devfeed.tech/topics/c-plus-plus.md>)

Tags: [2022](<https://devfeed.tech/tags/2022.md>), [books](<https://devfeed.tech/tags/books.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [course](<https://devfeed.tech/tags/course.md>), [developers](<https://devfeed.tech/tags/developers.md>), [leanpub](<https://devfeed.tech/tags/leanpub.md>)

### AI overview

The author announces that the C++ Concepts book has been converted into a Leanpub course. The course divides the material into fifteen shorter lessons with quizzes, exercises, model answers, and corrections to issues in the original book, including compiler-related and code fixes.

### Source excerpt

When I published C++ Concepts as a book back in 2022, I was happy with how it turned out. It covered the right material at the right depth, and the feedback from readers was positive. But a book is a passive experience -- you read, you nod, you move on. I recently learned about Leanpub courses and I thought that it's time to try something new. So I turned C++ Concepts it into a Leanpub course. ...

## C++26: std::hive

DevFeed: [C++26: std::hive](<https://devfeed.tech/articles/c-26-std-hive-53292.md>)

Original publisher: [Read original article](<https://www.sandordargo.com/blog/2026/09/02/cpp26-hive>)

Author: Sandor Dargo

Published: 2026-09-01T22:00:00Z

Content type: article

Language: en

Sources: [Sandor Dargo's Blog](<https://devfeed.tech/sources/sandor-dargo-s-blog.md>)

Topics: [Library](<https://devfeed.tech/topics/library.md>), [Cache](<https://devfeed.tech/topics/cache.md>), [iteration](<https://devfeed.tech/topics/iteration.md>), [Game engine](<https://devfeed.tech/topics/game-engine.md>)

Tags: [article](<https://devfeed.tech/tags/article.md>), [cache](<https://devfeed.tech/tags/cache.md>), [dev](<https://devfeed.tech/tags/dev.md>), [library](<https://devfeed.tech/tags/library.md>), [performance](<https://devfeed.tech/tags/performance.md>)

### AI overview

This article explains C++26's std::hive container, focusing on stable pointers and iterators, amortized constant-time insertion and erasure, cache locality, skipfields, independently allocated memory blocks, and reuse of erased slots.

### Source excerpt

In a recent article on std::inplace_vector, I mentioned that C++26 is generous with new containers. Here's the other one: std::hive. Consider a game engine managing thousands of entities. Each entity is stored in a container, and other subsystems hold pointers to those entities. When an entity is destroyed, you erase it from the container. With std::vector, every element after the erased one s...

## I helped to build GetCracked's Intermediate C++ Roadmap

DevFeed: [I helped to build GetCracked's Intermediate C++ Roadmap](<https://devfeed.tech/articles/i-helped-to-build-getcracked-s-intermediate-c-roadmap-53291.md>)

Original publisher: [Read original article](<https://www.sandordargo.com/blog/2026/08/28/getcracked-intermediate-cpp-roadmap>)

Author: Sandor Dargo

Published: 2026-08-27T22:00:00Z

Content type: article

Language: en

Sources: [Sandor Dargo's Blog](<https://devfeed.tech/sources/sandor-dargo-s-blog.md>)

Topics: [C++](<https://devfeed.tech/topics/c-plus-plus.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [Algorithms](<https://devfeed.tech/topics/algorithms.md>)

Tags: [authoring](<https://devfeed.tech/tags/authoring.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [coding](<https://devfeed.tech/tags/coding.md>), [dev](<https://devfeed.tech/tags/dev.md>), [developers](<https://devfeed.tech/tags/developers.md>), [evaluation](<https://devfeed.tech/tags/evaluation.md>), [interactive](<https://devfeed.tech/tags/interactive.md>), [learning](<https://devfeed.tech/tags/learning.md>), [roadmap](<https://devfeed.tech/tags/roadmap.md>)

### AI overview

The author describes helping build GetCracked's interactive roadmap for intermediate C++ developers by writing quiz questions, curating resources, and explaining concepts. The roadmap covers modern C++ topics including formatting, object creation, containers, type erasure, templates, ranges, time, memory, and callable utilities.

### Source excerpt

A few months ago, Coding Jesus reached out to me about collaborating on content for GetCracked, his C++ learning platform. The pitch was simple: he was building an interactive roadmap for intermediate C++ developers and wanted someone to help with building the technical content -- quiz questions, curated resources, explanations. That sounded like exactly the kind of work I enjoy, so I said yes. ...