Hacker News: BenFrantzDale

New comment by BenFrantzDale in "I still prefer MCP over skills"

BenFrantzDale — Fri, 10 Apr 2026 02:49:38 +0000

> Skills are good for instilling non-repeatable, yet intuitive or institutional knowledge.

What about just putting that sort of thing in human-targeted documentation? Why call it a “skill” and hide it somewhere a human is less likely to look?

(Skills are nice for providing /shortcuts.)

New comment by BenFrantzDale in "Show HN: Coros – A Modern C++ Library for Task Parallelism"

BenFrantzDale — Thu, 26 Sep 2024 01:08:08 +0000

Have you compared perf with the reference implementation of the P2300 “Senders” proposal? https://github.com/NVIDIA/stdexec

New comment by BenFrantzDale in "The C++ Iceberg"

BenFrantzDale — Wed, 08 May 2024 10:41:36 +0000

Having it available means we can use it explicitly. For example, I could see a compiler flag making `std::vector::operator[]` be checked and then if profiling warrants, remove the check by explicitly checking if my index is out of bounds and invoking UB. Not saying that’s the pattern people will use, but having an escape hatch makes safer-by-default behavior more approachable.

New comment by BenFrantzDale in "The C++ Iceberg"

BenFrantzDale — Wed, 08 May 2024 10:35:34 +0000

As a C++ user, shared_ptr is great for some things, but it is an anti-pattern. Shared_ptr is much much better. The problem is that shared_ptr isn’t value-semantic and so destroys local reasoning. That said, there are places for it, but it’s very easy to make a mess with it.

I’m a huge gain of stlab::copy_on_write, which is fundamentally very similar but which is value-semantic, doesn’t let you make loops, and gives You local reasoning.

New comment by BenFrantzDale in "Xz: Can you spot the single character that disabled Linux landlock?"

BenFrantzDale — Sun, 31 Mar 2024 19:39:12 +0000

Agreed. I just opened https://gitlab.kitware.com/cmake/cmake/-/issues/25846 although I have no idea how hard it is to address this sort of issue robustly.

New comment by BenFrantzDale in "The C++ Killers (Not You, Rust)"

BenFrantzDale — Thu, 21 Mar 2024 10:49:43 +0000

I agree. I wish we had to say `int x = std::uninitialized;`

New comment by BenFrantzDale in "Talking with the inventor of C++ [video]"

BenFrantzDale — Sun, 03 Dec 2023 14:46:34 +0000

Can you express value semantics in Python, or is everything still passed by mutable reference still and duck-typed at runtime? I’m being flip, and I like Python for some things, but for large robust performant software I find C++ way easier to work with as it works with me not against me to wrangle complexity.

New comment by BenFrantzDale in "Push ifs up and fors down"

BenFrantzDale — Thu, 16 Nov 2023 12:30:50 +0000

I thought that too. I think the point there was that you don’t have to push this notion as afar as in/out of functions: that just flipping them within a function can be beneficial.

New comment by BenFrantzDale in "Push ifs up and fors down"

BenFrantzDale — Thu, 16 Nov 2023 03:55:47 +0000

I agrée with them and with you. It looks like they work in some poor language that doesn’t allow overloading. Their example of `frobnicate`ing an optional being bad made me think: why not both? `void frobnicate(Foo&); void frobnicate(std::optional& foo) { if (foo.has_value()) { frobnicate(foo); } }`. Now you can frobnicate `Foo`s and optional ones!

New comment by BenFrantzDale in "Formatting text in C++: Old and new ways"

BenFrantzDale — Sat, 16 Sep 2023 21:18:16 +0000

For list comprehension, we have (C++23): `std::ranges::to(items | std::views::filter(shouldInclude) | std::views::transform(f))` it’s not quite `[f(x) for x in items if shouldInclude(x)]` but it’s the same idea.

New comment by BenFrantzDale in "Linear code is more readable"

BenFrantzDale — Fri, 15 Sep 2023 11:45:03 +0000

That’s what tests are for. And if `print_table` is factored properly then they won’t want to add flags, they’ll make a new function out of the pieces of `print_table` that has distinct behavior of its own.

New comment by BenFrantzDale in "Linear code is more readable"

BenFrantzDale — Fri, 15 Sep 2023 11:41:46 +0000

If the sub-functions could be reused and people would be tempted to change them, then that’s what your tests are for. In fact, it’s often tricky to test the sun-function logic without pulling them out because to write the test you have to figure out how to trick the outer function to get into certain states. Follow the Beyoncé rule: if you like it: put a test on it. Otherwise it’s on you if someone breaks it.

New comment by BenFrantzDale in "Linear code is more readable"

BenFrantzDale — Fri, 15 Sep 2023 11:38:05 +0000

I totally agree. And you can always write mutating “functions” (what get called “algorithms” in the C++ world), like C++’s `std::ranges::sort(range)`.

New comment by BenFrantzDale in "Linear code is more readable"

BenFrantzDale — Fri, 15 Sep 2023 10:33:58 +0000

This blogger obviously wouldn’t get along with Sean Parent of Adobe. It’s old but I have everyone on my team watch this “no raw loops” presentation: https://youtu.be/W2tWOdzgXHA?si=4LKv1-sau60U63op in which he identifies reusable patterns hiding in code (“That’s a rotate!”) I myself was skeptical at first but have found over the years that breaking functions into pieces is the only way to maintain short functions that can be reasoned about in isolation, and as a side effect, surfaces reusable code. If you can’t write functions that easily fit on a page, I posit you don’t actually know what the function is supposed to be doing, and there’s probably a bug. (If you can’t hold the whole function in your head, how can you be sure there isn’t a bug?)

New comment by BenFrantzDale in "Are Implicit Operators a Path to Clean Code or a Buggy Nightmare?"

BenFrantzDale — Wed, 09 Aug 2023 11:26:33 +0000

I write C++ including the conventions around the strong units library we use. What this article promote as “better” seems pretty bad. They dont like `Money m = new Money(10.0m); decimal amount = m.Amount;` and images prefer `Money m = 10.0m; decimal amount = m;`. While it’s nice to not have to say `new`, the implicit conversion in and out of strong units is terrifying and defeats the purpose. For example, while I generally like C++’s `std::chrono` library, it s `duration` types have a `.count()` member function to extract the number. But if you change the type from `std::chrono::seconds` to `std::chrono::milliseconds`, then `.count()` silently changes from “number of seconds” to “number of milliseconds”. For full safety, you need to name the units to “unpack” them. E.g., `Speed_mmps speed = 10.0_mm / 2.0_s; float speed_mm_per_s = getCount(speed);` where if the type of `speed` changed to furlongs per fortnight, the `getCount` call would either not compile or be correct up to floating-point precision.

New comment by BenFrantzDale in "Speed Up C++ Compilation"

BenFrantzDale — Sat, 05 Aug 2023 22:47:05 +0000

And conversely, if you are using classical polymorphism, you can get essentially the effect of PImpl by having an abstract base class with a static factory function that returns a unique pointer, then implement that factory function by in the cpp file having a concrete class that is defined there and returned as a `std::unique_ptr`. That gives you separation of API from implementation without a memory indirection, but you then can’t have it as a value type.

New comment by BenFrantzDale in "Speed Up C++ Compilation"

BenFrantzDale — Sat, 05 Aug 2023 22:41:00 +0000

I’m curious: do you use a `const std::unique_ptr` or just a `std::unique_ptr` or do you have a template that provides value semantics for the `Impl`? If I used PImpl a lot I’d make a `value` that encapsulates ownership with value semantics.

New comment by BenFrantzDale in "Speed Up C++ Compilation"

BenFrantzDale — Sat, 05 Aug 2023 21:01:17 +0000

If your internal representation is stable, you can put private functions in a private friend class that is only defined in the cpp file: `private struct access; friend struct access;`.

New comment by BenFrantzDale in "STX – C++17 and C++ 20 error-handling and utility extensions"

BenFrantzDale — Sun, 23 Jul 2023 02:38:23 +0000

C++ also has `std::expected`.

New comment by BenFrantzDale in "LLMs aren't even as smart as dogs, says Meta's AI chief scientist"

BenFrantzDale — Sun, 18 Jun 2023 02:13:33 +0000

What I find most fascinating about LLMs isn’t that they are smart but that they are different from the smarts I’m used to. It’s not that smart but it knows far more than any human ever could. It’s not smart, but it is well-read. It has read more than anyone and it makes up for its lack of smarts with that, making it a different sort of intelligence, if you can even call it that.