<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: pron</title><link>https://news.ycombinator.com/user?id=pron</link><description>Hacker News RSS</description><docs>https://hnrss.org/</docs><generator>hnrss v2.1.1</generator><lastBuildDate>Sat, 21 Nov 2026 17:14:15 +0000</lastBuildDate><atom:link href="https://hnrss.org/user?id=pron" rel="self" type="application/rss+xml"></atom:link><item><title><![CDATA[New comment by pron in "The G1 Garbage Collector"]]></title><description><![CDATA[
<p>It is true that if the size of your RAM is close to the size of your live set, a moving GC isn't the best choice, but this doesn't happen for most software on machines that we would call computers these days.<p>As for performance differences in practice, it is easy to encounter Java programs, typically either large ones or very concurrent ones, that easily outperform C++ programs by a factor of two or more, just as it's easy to see examples of the opposite, typically in smaller or less concurrent programs. This is what we would expect.<p>As experienced low-level programmers know, it is quite easy to avoid the operations that are slow in C++ or other low-level languages - heap allocations and dynamic dispatch - when programs are relatively small and/or young. As programs grow larger, it gets more and more expensive to do this because these operations offer high abstraction, the ability to keep changes local. And it is these two operations that the HotSpot JVM was built to optimise.<p>I gave a talk about exactly that at the last Devoxx: <a href="https://youtu.be/vhDwy1eCXbs" rel="nofollow">https://youtu.be/vhDwy1eCXbs</a></p>
]]></description><pubDate>Sat, 21 Nov 2026 12:14:49 +0000</pubDate><link>https://news.ycombinator.com/item?id=50588427</link><dc:creator>pron</dc:creator><comments>https://news.ycombinator.com/item?id=50588427</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=50588427</guid></item><item><title><![CDATA[New comment by pron in "The G1 Garbage Collector"]]></title><description><![CDATA[
<p>Yes, I'm aware that the title of that paper isn't actually a true statement.</p>
]]></description><pubDate>Sat, 21 Nov 2026 11:01:41 +0000</pubDate><link>https://news.ycombinator.com/item?id=50588002</link><dc:creator>pron</dc:creator><comments>https://news.ycombinator.com/item?id=50588002</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=50588002</guid></item><item><title><![CDATA[New comment by pron in "The G1 Garbage Collector"]]></title><description><![CDATA[
<p>Even ZGC now offers better predictablity than malloc/free allocators (which are a long way from predictable as far latency goes). But some hard-realtime software uses (or at least used to) RTSJ, a hard-realtime version of Java, that separates the heap to a part that uses a GC and a part that uses nested arenas. It was a big deal twenty years ago, when I worked on such software. I don't know how much it's still used. Probably not much. C is still king in that world, and Ada too, to some extent.<p>It's important to know that for hard realtime, even C alone isn't enough, though, and you need special kernels. Ordinary OS schedulers aren't predictable enough for hard realtime.</p>
]]></description><pubDate>Fri, 20 Nov 2026 22:33:29 +0000</pubDate><link>https://news.ycombinator.com/item?id=50583299</link><dc:creator>pron</dc:creator><comments>https://news.ycombinator.com/item?id=50583299</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=50583299</guid></item><item><title><![CDATA[New comment by pron in "The G1 Garbage Collector"]]></title><description><![CDATA[
<p>That is just wrong. Moving GCs were invented because they're more efficient than manual memory management. In fact, in his famous 1986 paper, <i>Garbage Collection Can Be Faster Than Stack Allocation</i>, Andrew Appel wrote: "It is easy to believe that one must pay a price in efficiency for this ease in programming… But this is simply not true."<p>Moving GCs free you from the high overhead of malloc/free runtimes, something that us old C and C++ programmers have had decades of experience with, and why our colleagues developed large, complex runtimes such as TCMalloc and jemalloc to remove some of that overhead, even though not nearly as much as moving GCs do.<p>The reason low-level languages don't use moving collectors despite their superior efficiency is because they must give up on some performance optimisations for the abillity to interact with the hardware or OS directly, and that means that pointers must be stable machine addresses (this is why you need a richer FFI layer in Java). Moving collectors work in many ways like arenas. They don't need to maintain free lists whenever an object is allocated or freed (in fact, they never free any object at all), and memory is freed in bulk. This is not the only performance that low-level languages leave on the table because above everything else they must be low level.<p>Every single language that <i>can</i> use moving collectors does (it's also a matter of resources; moving collectors are hard to implement, especially the modern pauseless ones).<p>Sadly, people who are not compiler or memory allocator engineers don't know that, so they believe "popular wisdom" disseminated by other non-experts.<p>P.S.<p>Re AI: It's certainly possible that AI will be able to write good, efficient, large software some day, perhaps soon, but if it's able to perform the global program transformations required to replicate the optimisations of a moving collector without one, it won't need the simpler and more local optimisations done by a compiler, and will be able to work better without one, directly in machine code, in which case all compilers and programming languages are also done. In other words, moving GCs will not be a relic of the past before compilers are (or maybe roughly around the same time).</p>
]]></description><pubDate>Fri, 20 Nov 2026 20:54:39 +0000</pubDate><link>https://news.ycombinator.com/item?id=50581924</link><dc:creator>pron</dc:creator><comments>https://news.ycombinator.com/item?id=50581924</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=50581924</guid></item><item><title><![CDATA[New comment by pron in "The G1 Garbage Collector"]]></title><description><![CDATA[
<p>That is not so simple. First, the differences among different GCs are bigger than between some GCs and no GC. Second, moving GCs - of the kind used in HotSpot (as well as V8 and .NET), but not Go or Python (which are as different from each other as they are from moving GCs) - do, indeed have a higher memory utilisation, but it's not necessarily inefficient, because most of it comes into effect when CPU is under higher pressure than RAM (that's when you get a larger young-gen, as the heap overhead is a function of the allocation rate, not of the live set which, in turn, means a high CPU usage). RAM and CPU are not independent resources; the most basic way to think about this is that your machine is exhausted when the <i>first</i> of CPU and RAM is exhausted. For example, I can take your car battery or I can take your petrol, but if I take your car battery when you don't have petrol, I'm not impacting your use of the car, so I'm not really creating any "inefficiency".<p>You are right, though, that in a very memory-constrained environment, usually embedded devices, you may want to lower memory consumption regardless of anything else, and in such environments moving GCs are probably not what you want (although other kinds of GC could be).<p>More here: <a href="https://youtu.be/xr73mR7ii9M" rel="nofollow">https://youtu.be/xr73mR7ii9M</a></p>
]]></description><pubDate>Fri, 20 Nov 2026 20:49:45 +0000</pubDate><link>https://news.ycombinator.com/item?id=50581852</link><dc:creator>pron</dc:creator><comments>https://news.ycombinator.com/item?id=50581852</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=50581852</guid></item><item><title><![CDATA[New comment by pron in "Someone reported java4shell bug in September 2026"]]></title><description><![CDATA[
<p>> When a security vulnerability becomes public like this (regardless of why or by whom), that should have impact on timeline for fix, and maybe also communications. The cat's out of the bag already and no amount of silence will put it back in.<p>Not all vulnerabilities are created equal, and they don't all justify an emergency release (the JDK has regular quarterly releases for security patches). Until you know the impact, disrupting your users is not the best path to security (just as you don't want to police to respond to every suspicious occurrence).<p>> I don't think 1 month is reasonable timeline for a publicly known vulnerability like this.<p>It wasn't a publicly known vulnerability; it was a publicly known bug. If the original reporter had thought this to be a vulnerability he wouldn't have reported it like that (he's a former colleague who's familiar with project policies).</p>
]]></description><pubDate>Fri, 20 Nov 2026 19:47:50 +0000</pubDate><link>https://news.ycombinator.com/item?id=50580822</link><dc:creator>pron</dc:creator><comments>https://news.ycombinator.com/item?id=50580822</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=50580822</guid></item><item><title><![CDATA[New comment by pron in "Someone reported java4shell bug in September 2026"]]></title><description><![CDATA[
<p>That would be the wrong thing to do. You don't know how severe the problem is and what to advise your users. Important products like this have regular quarterly updates, where the less risky vulnerabilities are patched. You can't just cut an emergency release that your users may not be prepared to apply before you know what the risk is.</p>
]]></description><pubDate>Fri, 20 Nov 2026 14:04:29 +0000</pubDate><link>https://news.ycombinator.com/item?id=50574823</link><dc:creator>pron</dc:creator><comments>https://news.ycombinator.com/item?id=50574823</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=50574823</guid></item><item><title><![CDATA[New comment by pron in "Someone reported java4shell bug in September 2026"]]></title><description><![CDATA[
<p>That would be irresponsible. A vulnerability isn't closed once you merge a fix, and not once you release builds. It's closed when users apply the patch in production. That takes time no matter how quickly you release, and could come at the expense of other things your users may want to do, including addressing other vulnerabilities. Turning a bug into an exploit can also take time, even with the help of AI.<p>So until you know how dangerous the bug is and have a plan for release (does it go in the next quarterly patch, which users are ready for, or are you making a special release?) you shouldn't do anything public because you don't yet know what to advise your users to do.</p>
]]></description><pubDate>Fri, 20 Nov 2026 14:00:31 +0000</pubDate><link>https://news.ycombinator.com/item?id=50574773</link><dc:creator>pron</dc:creator><comments>https://news.ycombinator.com/item?id=50574773</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=50574773</guid></item><item><title><![CDATA[New comment by pron in "Someone reported java4shell bug in September 2026"]]></title><description><![CDATA[
<p>When your product runs the world, you need to coordinate exactly how a patch is released across multiple versions and when, and you don't want to tip your hand before everything is ready. A lot is riding on doing this right.</p>
]]></description><pubDate>Fri, 20 Nov 2026 02:46:03 +0000</pubDate><link>https://news.ycombinator.com/item?id=50569530</link><dc:creator>pron</dc:creator><comments>https://news.ycombinator.com/item?id=50569530</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=50569530</guid></item><item><title><![CDATA[New comment by pron in "Ruby2ßhell: Pre-authentication RCE on stock Rails"]]></title><description><![CDATA[
<p>> This is nonsense. Java doesn't "compile like C or C++ or Rust or Zig" any more than Python does.<p>It really does, though. Perhaps you're unfamiliar?<p>> Unsafe is still plenty prevalent in Java, nor is the use of C++ libraries.<p>My statement was that unsafe is much more prevalent in Rust than in Java, and that is true.<p>> Yes, well, that's some handwaving.<p>I'm sorry that I can't teach you principles of compilation here, but feel free to dig deeper.<p>> Yes. It is still very prevelant.<p>Much less than in Rust.<p>> Ridiculous... A ridiculous comparison.<p>You don't sound like either a runtime or compiler engineer at all, or you wouldn't have found any of this ridiculous in the least (or news). In that case, I hope that telling you that what I wrote was true might enrage you enough to learn more about these subjects, and perhaps our community will have grown by another member.</p>
]]></description><pubDate>Fri, 20 Nov 2026 02:05:42 +0000</pubDate><link>https://news.ycombinator.com/item?id=50569261</link><dc:creator>pron</dc:creator><comments>https://news.ycombinator.com/item?id=50569261</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=50569261</guid></item><item><title><![CDATA[New comment by pron in "Someone reported java4shell bug in September 2026"]]></title><description><![CDATA[
<p>We <i>did</i> know it was a potential security risk, and that is why it was handled exactly how security-sensitive issues are supposed to be handled (not to mention that the reporter is a well-respected OpenJDK contributor and former Oracle colleague).<p>I don't know if people here understand how these things need to be done in the most important and critical open source projects, such as Linux or OpenJDK, but there are two things you must <i>not</i> do when an issue is suspected to be a risk until you've researched the matter and decided on a backport and release strategy: You shouldn't communicate publicly, and you absolutely shouldn't merge a patch.</p>
]]></description><pubDate>Fri, 20 Nov 2026 01:14:57 +0000</pubDate><link>https://news.ycombinator.com/item?id=50568926</link><dc:creator>pron</dc:creator><comments>https://news.ycombinator.com/item?id=50568926</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=50568926</guid></item><item><title><![CDATA[New comment by pron in "Someone reported java4shell bug in September 2026"]]></title><description><![CDATA[
<p>He's listed as the fix's co-author (and he's a friend; he's a regular contributor and a former Oracle employee).</p>
]]></description><pubDate>Fri, 20 Nov 2026 01:07:44 +0000</pubDate><link>https://news.ycombinator.com/item?id=50568875</link><dc:creator>pron</dc:creator><comments>https://news.ycombinator.com/item?id=50568875</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=50568875</guid></item><item><title><![CDATA[New comment by pron in "Ruby2ßhell: Pre-authentication RCE on stock Rails"]]></title><description><![CDATA[
<p>I know that you can write slow data structures in safe Rust, but the standard library's data structures are supposed to be efficient. Anyway, a quick look at how common unsafe is in Rust vs Java, both in the standard library and in applications, and you'll see that it's much more common in Rust.</p>
]]></description><pubDate>Thu, 19 Nov 2026 21:33:36 +0000</pubDate><link>https://news.ycombinator.com/item?id=50566723</link><dc:creator>pron</dc:creator><comments>https://news.ycombinator.com/item?id=50566723</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=50566723</guid></item><item><title><![CDATA[New comment by pron in "Ruby2ßhell: Pre-authentication RCE on stock Rails"]]></title><description><![CDATA[
<p>Then you're in for a surprise. Take a look at TCMalloc and jemalloc. They're almost the size of HotSpot's most complex GC, then non-pause ZGC.</p>
]]></description><pubDate>Thu, 19 Nov 2026 21:31:54 +0000</pubDate><link>https://news.ycombinator.com/item?id=50566699</link><dc:creator>pron</dc:creator><comments>https://news.ycombinator.com/item?id=50566699</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=50566699</guid></item><item><title><![CDATA[New comment by pron in "Someone reported java4shell bug in September 2026"]]></title><description><![CDATA[
<p>There were no public comments precisely because it was immediately identified as a potential security risk! The JDK is so critical and sensitive (probably the most important open source project after Linux) that we have policies that are more carefully considered than your average open source project (including most language compiler/runtime projects). We can allow no public comments and no public merges of code on anything that could be a security risk before the security research team studies it.</p>
]]></description><pubDate>Thu, 19 Nov 2026 20:46:30 +0000</pubDate><link>https://news.ycombinator.com/item?id=50566123</link><dc:creator>pron</dc:creator><comments>https://news.ycombinator.com/item?id=50566123</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=50566123</guid></item><item><title><![CDATA[New comment by pron in "Someone reported java4shell bug in September 2026"]]></title><description><![CDATA[
<p>That is precisely why it wasn't dismissed and why there were no public activity on this issue.</p>
]]></description><pubDate>Thu, 19 Nov 2026 20:44:02 +0000</pubDate><link>https://news.ycombinator.com/item?id=50566090</link><dc:creator>pron</dc:creator><comments>https://news.ycombinator.com/item?id=50566090</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=50566090</guid></item><item><title><![CDATA[New comment by pron in "Why Zig over C for Systems Programming"]]></title><description><![CDATA[
<p>You could certainly require parentheses, but it's not a "just", because infix operators are desirable in the first place for readability, and requiring to write something like `((((((a + b) + (c * d)) + e) + f) + g)` significantly reduces that advantage.</p>
]]></description><pubDate>Thu, 19 Nov 2026 20:21:23 +0000</pubDate><link>https://news.ycombinator.com/item?id=50565791</link><dc:creator>pron</dc:creator><comments>https://news.ycombinator.com/item?id=50565791</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=50565791</guid></item><item><title><![CDATA[New comment by pron in "Someone reported java4shell bug in September 2026"]]></title><description><![CDATA[
<p>Because it runs so much of the world's most important software, the JDK is heavily watched, and removing a PR would only draw attention to it.<p>Also, it's not really a leaked 0-day because there's ways to go from a bug to an exploit (even going from Calif's detailed public report to an exploit is not trivial, because exploits depend on the particular application; there has been no disclosed exploit that requires only the JDK).</p>
]]></description><pubDate>Thu, 19 Nov 2026 20:13:52 +0000</pubDate><link>https://news.ycombinator.com/item?id=50565679</link><dc:creator>pron</dc:creator><comments>https://news.ycombinator.com/item?id=50565679</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=50565679</guid></item><item><title><![CDATA[New comment by pron in "Someone reported java4shell bug in September 2026"]]></title><description><![CDATA[
<p>I work on the JDK, and while I have no involvement with this issue, knowing how we work, what has likely happened is quite the opposite. Bugs don't slip through our triage, and every bug that leads to a VM crash, especially in the compiler backend, is flagged for security review by the security research team; once that happens, no public communication is done. I don't know this is what happened here, but it is the most likely thing to have happened.<p>We're not talking any large open source project here. We're talking about a project that, like Linux, runs much of the world's software infrastructure, and even bugs that could <i>potentially</i> be vulnerabilities need to be handled with great care.</p>
]]></description><pubDate>Thu, 19 Nov 2026 19:00:53 +0000</pubDate><link>https://news.ycombinator.com/item?id=50564594</link><dc:creator>pron</dc:creator><comments>https://news.ycombinator.com/item?id=50564594</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=50564594</guid></item><item><title><![CDATA[New comment by pron in "Ruby2ßhell: Pre-authentication RCE on stock Rails"]]></title><description><![CDATA[
<p>> Java, and other languages like it, often drop into unsafe code where it's far weirder and less supported because they have to because the languages are too slow to do the work they want to do.<p>No, that's not been the case for a while, at least since the introduction of VarHandles and FFM (which is why Unsafe is now in the process of being removed altogether). Of course, there's nothing slow in Java code; it compiles like C or C++ or Rust or Zig, sometimes with more aggressive optimisations and sometimes with less aggressive ones. Unsafe mostly used to be used for certain memory operations before VarHandles and FFM.<p>> And obviously you have all of the complexity of a massive, JIT'd runtime written in C++.<p>No, that's also inaccurate. The "massive runtime" is largely a compiler (and it doesn't matter what language that's in), and memory management, where the Rust runtime is also about as massive and written in C (the various malloc/free implementations).</p>
]]></description><pubDate>Thu, 19 Nov 2026 16:32:53 +0000</pubDate><link>https://news.ycombinator.com/item?id=50562295</link><dc:creator>pron</dc:creator><comments>https://news.ycombinator.com/item?id=50562295</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=50562295</guid></item></channel></rss>