<rss version="2.0" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Hacker News: jstimpfle</title><link>https://news.ycombinator.com/user?id=jstimpfle</link><description>Hacker News RSS</description><docs>https://hnrss.org/</docs><generator>hnrss v2.1.1</generator><lastBuildDate>Fri, 20 Nov 2026 18:21:06 +0000</lastBuildDate><atom:link href="https://hnrss.org/user?id=jstimpfle" rel="self" type="application/rss+xml"></atom:link><item><title><![CDATA[New comment by jstimpfle in "Software is breaking down at a systemic level"]]></title><description><![CDATA[
<p>My impression is it's always been a mixed bag. The level of bugginess has been relatively constant. In the meantime, scope and capabilities have gone way up. I hate Teams and Outlook and the virus scanner on my company's laptop though. Those are keeping me from doing my work. Windows + anti-virus makes file access and process spawning 10x to 100x slower compared to a Linux machine.</p>
]]></description><pubDate>Mon, 16 Nov 2026 18:32:07 +0000</pubDate><link>https://news.ycombinator.com/item?id=50521055</link><dc:creator>jstimpfle</dc:creator><comments>https://news.ycombinator.com/item?id=50521055</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=50521055</guid></item><item><title><![CDATA[New comment by jstimpfle in "Jonathan Blow – If AI solved coding, why is my software still the same? [video]"]]></title><description><![CDATA[
<p>I have the impression he has listened to people like you and has come across significantly less negatively in the last couple years. Apart from that, there has always been a lot of substance, attesting only a superiority complex is not at all doing him justice in my opinion.<p>I for one love to watch and listen to him, not for the fact that I find myself agreeing to so much of what he says, but because he is able to express things in very insightful ways. And yes, I'm a sucker for that "no bullshit" attitude.</p>
]]></description><pubDate>Sat, 14 Nov 2026 15:42:05 +0000</pubDate><link>https://news.ycombinator.com/item?id=50497905</link><dc:creator>jstimpfle</dc:creator><comments>https://news.ycombinator.com/item?id=50497905</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=50497905</guid></item><item><title><![CDATA[New comment by jstimpfle in "Jonathan Blow – If AI solved coding, why is my software still the same? [video]"]]></title><description><![CDATA[
<p>I have to use Outlook and Teams for work, and both have had a notification symbol on with "1" unread items for most of the past year, even though clearly everything has been looked at.</p>
]]></description><pubDate>Sat, 14 Nov 2026 15:36:39 +0000</pubDate><link>https://news.ycombinator.com/item?id=50497848</link><dc:creator>jstimpfle</dc:creator><comments>https://news.ycombinator.com/item?id=50497848</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=50497848</guid></item><item><title><![CDATA[New comment by jstimpfle in "Jonathan Blow – If AI solved coding, why is my software still the same? [video]"]]></title><description><![CDATA[
<p>To me it's been a great aid as a rubber duck and general research tool. Totally agree that it can barely help coming up with a good architecture. But it's quite capable of understanding an existing or a suggested one, even somewhat capable (though clearly not surpassing the best humans) at evaluating it.</p>
]]></description><pubDate>Sat, 14 Nov 2026 15:16:43 +0000</pubDate><link>https://news.ycombinator.com/item?id=50497696</link><dc:creator>jstimpfle</dc:creator><comments>https://news.ycombinator.com/item?id=50497696</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=50497696</guid></item><item><title><![CDATA[New comment by jstimpfle in "El Niño is flooding California's coasts with the highest tides to come"]]></title><description><![CDATA[
<p>Probably reading something into this that I didn't mean?</p>
]]></description><pubDate>Sat, 31 Oct 2026 09:00:31 +0000</pubDate><link>https://news.ycombinator.com/item?id=50314295</link><dc:creator>jstimpfle</dc:creator><comments>https://news.ycombinator.com/item?id=50314295</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=50314295</guid></item><item><title><![CDATA[New comment by jstimpfle in "El Niño is flooding California's coasts with the highest tides to come"]]></title><description><![CDATA[
<p>About progressive taxes. That would make the super rich not super rich. But it would not fix state finances. (Also of course it's not realistic to think that the super rich will just give 100% of their money for nothing in exchange).<p>If the state needs money, it needs to take it from where it is, which is still with the masses. In Germany, at around maybe 90k EUR income is a particularly bad place to be. You are nominally considered to be a good earner. But at that point you already give around 70% on the next EUR you earn for various taxes and social security. If you are financially responsible not only for yourself but for other people (which is not reflected in lower taxes unless you're legally married), you can still get along fine, but it might not feel like you are a good earner. I was in a similar situation at one point in my life, it had taken me hard work to earn that money, and I have to say I was a little pissed about the tax situation.<p>I think I understand why progressive tax systems exist. Given our societies' structures, they probably _have_ to exist. But also I wonder if long-term they _contribute_ to income and wealth inequality. It reduces incentives for those who earn less to earn more (which of course for many people is not easily possible, but for some it would be, by working more, working harder, looking for a different job, etc.). It also allows employers to spend less on their workforce, meaning you could understand it as a kind of subsidiary for employers. Of course, lower salaries might be the only way for employers to even offer a product at prices the market wants to pay. But again it also reenforces inequalities in the income structure.</p>
]]></description><pubDate>Fri, 30 Oct 2026 09:09:08 +0000</pubDate><link>https://news.ycombinator.com/item?id=50301422</link><dc:creator>jstimpfle</dc:creator><comments>https://news.ycombinator.com/item?id=50301422</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=50301422</guid></item><item><title><![CDATA[New comment by jstimpfle in "Four Months of Zig"]]></title><description><![CDATA[
<p>That's just a matter of wrapping the allocator if you feel fhat is better approach. Question is, should there always be an allocator around with arr or do you want to split a build phase from an immutable use phase.</p>
]]></description><pubDate>Wed, 28 Oct 2026 08:00:33 +0000</pubDate><link>https://news.ycombinator.com/item?id=50270452</link><dc:creator>jstimpfle</dc:creator><comments>https://news.ycombinator.com/item?id=50270452</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=50270452</guid></item><item><title><![CDATA[New comment by jstimpfle in "C for Rust programmers"]]></title><description><![CDATA[
<p>I find both of these names too long and the colons are noisy. The fact that I can refer to them using different qualifications makes me uneasy. For both we could find better names, e.g. MemoryOrder is already an established term.<p>I've realized that naming is an art that is difficult to master but makes a huge difference when gotten right. It consists of not just combining names into compounds but also finding new shorter names that are ergonomic and distinguishable. For example, I've replaced the compound "NodeIntersectTest" in my current project with simply "Probe", which is much easier to read and write, easy to distinguish from other terms after learning its meaning once (it is a central concept to my app), and also perfect for log messages and stats where brevity matters a lot.<p>A two letter prefix for all identifiers in a project or company codebase is a good idea, but I try to avoid
hierarchies and finer granularity, and generally to be overspecific, in order to keep things easier to change later.</p>
]]></description><pubDate>Mon, 12 Oct 2026 00:08:41 +0000</pubDate><link>https://news.ycombinator.com/item?id=50049541</link><dc:creator>jstimpfle</dc:creator><comments>https://news.ycombinator.com/item?id=50049541</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=50049541</guid></item><item><title><![CDATA[New comment by jstimpfle in "C for Rust programmers"]]></title><description><![CDATA[
<p>True that integer promotion rules are defined in terms of the machine dependent unsized "real" integer types. That is indeed annoying. I guess I've found ways to cope. Good thing is, those promotions never cast down, they only widen types.<p>The point of namespaces is exactly to allow less qualified names, to allow spending less energy when creating new names, by having the compiler always add a qualification implicitly. However, that doesn't solve the problem with name collisions when reading or grepping the source code -- it actually makes it much worse. And avoiding those name collisions, i.e. what's in the source literally, what the programmer reads, and what less-than-perfect tools see, is at least as important as avoiding "semantic" name collisions and being able to compile the code.<p>Namespaces not only encourage many more literal collisions -- now a single name can be available in various shortenings, and even under different aliases, which also makes it hard to tell that two symbols refer to the same thing!<p>I've found that the only way to get names right is to find a good scheme, to find meaningful good prefixes, suffixes, and abbreviations, and to come up with a system to create new names more mechanically but still keep them as short and readable as possible.</p>
]]></description><pubDate>Sun, 11 Oct 2026 21:56:20 +0000</pubDate><link>https://news.ycombinator.com/item?id=50048274</link><dc:creator>jstimpfle</dc:creator><comments>https://news.ycombinator.com/item?id=50048274</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=50048274</guid></item><item><title><![CDATA[New comment by jstimpfle in "C for Rust programmers"]]></title><description><![CDATA[
<p>True. In C, it's hard to know what's defined where and what dependencies one is even using unknowingly. The only help is to build on multiple platforms from early on, this will reduce the pain of porting to new platforms later.</p>
]]></description><pubDate>Sun, 11 Oct 2026 10:34:05 +0000</pubDate><link>https://news.ycombinator.com/item?id=50041664</link><dc:creator>jstimpfle</dc:creator><comments>https://news.ycombinator.com/item?id=50041664</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=50041664</guid></item><item><title><![CDATA[New comment by jstimpfle in "C for Rust programmers"]]></title><description><![CDATA[
<p>Integer widths are a problem, but hardly the biggest headache (unless it's a decade old preexisting project that was never designed with portability in mind). Fixed width integer types like int32_t have existed for decades. Even Rust has usize which is machine dependent, and pointers as well have to be machine dependent of course.<p>Much bigger problem is understanding the scope of dependencies. Dependencies can go bad and you need to update. A dependency might not be available on some new platform so you might have to replace with something else on that platform. To make the software portable, good modularity is required. This is to a large extent an aspect of software architecture. Even Rust can't magically make this happen, if you depend on 300 crates that's probably not a great place to be in either if you want to be portable and maintainable.<p>There is probably a point that C's flat namespace is a major contributor to badly designed software, because people aren't aware of the dependencies they're mixing all the time. Also C encourages transitive includes, leaking implementation details to the user instead of just to the compiler. (But btw. I find C++ and Rust namespace to be unergonomic syntax-wise, and what's needed is not actually namespaces but control over visibility).</p>
]]></description><pubDate>Sun, 11 Oct 2026 10:31:00 +0000</pubDate><link>https://news.ycombinator.com/item?id=50041640</link><dc:creator>jstimpfle</dc:creator><comments>https://news.ycombinator.com/item?id=50041640</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=50041640</guid></item><item><title><![CDATA[New comment by jstimpfle in "C for Rust programmers"]]></title><description><![CDATA[
<p>It's _very_ easy to write C that is impossible to port to other platforms or other compilers. The reason is that more than for most other ecosystems, there are many different implementations with their own implementations and quirks.<p>It's also easy to write C that won't build on the system it was originally developed on, a few years down the line. But that is true for almost every other language ecosystem. I would say, C makes it _possible_ to write code in such a way that it works on many different platforms and compilers, and/or can continue to work in decades to come with relatively little maintenance.<p>The latter isn't true for most other ecosystems, because to get anything done in them, you need to rely more on that language and its ecosystem -- specific language features, specific libraries. C isn't a glue code language. It's very good at letting you create your own thing.<p>To do it well though, requires a lot of care and expertise.</p>
]]></description><pubDate>Sun, 11 Oct 2026 09:03:05 +0000</pubDate><link>https://news.ycombinator.com/item?id=50041135</link><dc:creator>jstimpfle</dc:creator><comments>https://news.ycombinator.com/item?id=50041135</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=50041135</guid></item><item><title><![CDATA[New comment by jstimpfle in "Type Safe Generic Data Structures in C (2025)"]]></title><description><![CDATA[
<p>It couples things and complicates things. Which creates friction against when refactoring a software architecture, making it harder to scale it up.<p>Fully agree, for locks or other simple begin/end pairs it doesn't create the same kind of architectural damage. But I don't use it even there, because RAII fundamentally doesn't play well with manual cleanup code. It's kind of an all-in game, if you use some RAII there are strong forces (whenever you need to get the "nesting" right) to convert all remaining manual begin/end type code to types that define that functionality out-of-line in the destructor/destructor, leading to fragmentation.</p>
]]></description><pubDate>Tue, 06 Oct 2026 14:49:34 +0000</pubDate><link>https://news.ycombinator.com/item?id=49979363</link><dc:creator>jstimpfle</dc:creator><comments>https://news.ycombinator.com/item?id=49979363</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=49979363</guid></item><item><title><![CDATA[New comment by jstimpfle in "Type Safe Generic Data Structures in C (2025)"]]></title><description><![CDATA[
<p>No need to invent when you already know how it works.<p>I could re-type all the essential stuff from std::string that I've ever used myself within 10 minutes, no problem, without looking up external sources, including copy & move semantics and whatnot. But I'm deliberately not doing it. Because I don't like this "invention".</p>
]]></description><pubDate>Tue, 06 Oct 2026 09:39:54 +0000</pubDate><link>https://news.ycombinator.com/item?id=49976220</link><dc:creator>jstimpfle</dc:creator><comments>https://news.ycombinator.com/item?id=49976220</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=49976220</guid></item><item><title><![CDATA[New comment by jstimpfle in "Type Safe Generic Data Structures in C (2025)"]]></title><description><![CDATA[
<p>The projects and people I follow do this all the time. Just like putting a size field near each regular non sentinel terminated array is useful. But if not doing it (maybe linux kernel in many cases), no big deal either, don't sweat the small stuff. String slices are small and rarely perf critical.</p>
]]></description><pubDate>Tue, 06 Oct 2026 07:05:28 +0000</pubDate><link>https://news.ycombinator.com/item?id=49975182</link><dc:creator>jstimpfle</dc:creator><comments>https://news.ycombinator.com/item?id=49975182</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=49975182</guid></item><item><title><![CDATA[New comment by jstimpfle in "Type Safe Generic Data Structures in C (2025)"]]></title><description><![CDATA[
<p>Placing data in .rodata (read only memory) is an actual useful application of const keyword. Not specific to embedded. Arguably there shouldn't have been multiple slightly different meanings of the keyword like that.<p>I don't know why you are now jumping to setjmp/longjmp, trying to make a point that somehow C is the worst programming languages ever, when all I am trying to argue is for sane programming practices, hinting that more complex features (line especially found in newer languages) are not solutions but part of the complexity problem.</p>
]]></description><pubDate>Tue, 06 Oct 2026 06:45:47 +0000</pubDate><link>https://news.ycombinator.com/item?id=49975066</link><dc:creator>jstimpfle</dc:creator><comments>https://news.ycombinator.com/item?id=49975066</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=49975066</guid></item><item><title><![CDATA[New comment by jstimpfle in "Type Safe Generic Data Structures in C (2025)"]]></title><description><![CDATA[
<p>Yeah... There are libraries like Google Highway but that seems to me like a bulky software abstraction layer even if it is a so-called "zero cost" abstraction. Maybe appropriate in some cases. In my case, I've implemented a couple of lines for AVX2 and AVX512, maybe around 100 lines for the most perf sensitive sections currently, not a big deal. The actual work is in the understanding of the problem and of the phyiscal hardware, and in the software architecture and data layout to even enable vectorized stream processing in the first place. I'm not concerned writing a couple of perf sensitive lines against 2-3 most important concrete vector ISAs. I also fancy adding a GPU backend later (requires D3D12/SM6.0 API level), Highway couldn't help with that.</p>
]]></description><pubDate>Mon, 05 Oct 2026 23:00:29 +0000</pubDate><link>https://news.ycombinator.com/item?id=49971961</link><dc:creator>jstimpfle</dc:creator><comments>https://news.ycombinator.com/item?id=49971961</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=49971961</guid></item><item><title><![CDATA[New comment by jstimpfle in "Type Safe Generic Data Structures in C (2025)"]]></title><description><![CDATA[
<p>> Do you expect some other behavior in such case?<p>No, just saying this stuff is implicit and thus hard to read. More so the allocation on indexing assignment.
and keeping things which shouldn't be mutated const wasn't a problem at all.<p>> and keeping things which shouldn't be mutated const wasn't a problem at all.<p>As soon as datastructures become more complicated and more interconnected, it's not clear anymore what const should even mean (issues are similar as with deep vs shallow copies, how do you even draw the lines, where are the objects?).<p>And the major philosophical flaw in the const vs. non-const distinction is that to make a strict separation you have to move everything mutable into constructor calls (for the most part, not getting more into the weeds of C++). Which is very awkward, it's a real tradeoff you need to be aware of. I realized only after playing these games for a long time what a waste of time it is and how much complexity it creates.</p>
]]></description><pubDate>Mon, 05 Oct 2026 18:22:57 +0000</pubDate><link>https://news.ycombinator.com/item?id=49968506</link><dc:creator>jstimpfle</dc:creator><comments>https://news.ycombinator.com/item?id=49968506</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=49968506</guid></item><item><title><![CDATA[New comment by jstimpfle in "Type Safe Generic Data Structures in C (2025)"]]></title><description><![CDATA[
<p>You must be very experienced to be so judgemental! But maybe ask the many billions of voxels that get tested per second on my multithreaded and SIMD'ed cutting simulation.</p>
]]></description><pubDate>Mon, 05 Oct 2026 17:28:38 +0000</pubDate><link>https://news.ycombinator.com/item?id=49967789</link><dc:creator>jstimpfle</dc:creator><comments>https://news.ycombinator.com/item?id=49967789</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=49967789</guid></item><item><title><![CDATA[New comment by jstimpfle in "Type Safe Generic Data Structures in C (2025)"]]></title><description><![CDATA[
<p>> C++ containers are designed for average demands. If you need something more specific, you can always use an alternative implementation.<p>As someone who has been programming exclusively in C/C++ for a long time -- the biggest selling point for these languages in 2026 is exactly being suited to doing something specific, not generic.<p>> Allocations aren't implicit<p><pre><code>    std::map<int,int> m;
    m[1] = 42; // implicit alloc
    auto m2 = m; // implicit too

</code></pre>
> in C++ it's strictly recommended to mark as const everything in regular user code which shouldn't be mutated.<p>Theory and practice. Making everything const correct is too painful in practice, often impossible. It's a trap for bean counters that can't focus on getting some actual useful work done. I'm being harsh to my own past self here. Counter question: why include allocation mechanics with some existing data that never gets changed? Why should we have to add much <i>more</i> boilerplate to get the <i>simpler</i> thing?</p>
]]></description><pubDate>Mon, 05 Oct 2026 17:12:55 +0000</pubDate><link>https://news.ycombinator.com/item?id=49967589</link><dc:creator>jstimpfle</dc:creator><comments>https://news.ycombinator.com/item?id=49967589</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=49967589</guid></item></channel></rss>