<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: nanolith</title><link>https://news.ycombinator.com/user?id=nanolith</link><description>Hacker News RSS</description><docs>https://hnrss.org/</docs><generator>hnrss v2.1.1</generator><lastBuildDate>Fri, 20 Nov 2026 17:56:43 +0000</lastBuildDate><atom:link href="https://hnrss.org/user?id=nanolith" rel="self" type="application/rss+xml"></atom:link><item><title><![CDATA[New comment by nanolith in "Formal Verification Is Not Verifiable"]]></title><description><![CDATA[
<p>It's difficult to speculate about the future. We don't yet have the right kind of hardware -- whether it be performance, scale, etc -- to simulate the kind of synthetic intelligence necessary to outpace humans at reasoning.<p>It's not a matter of constructing proofs. This can be done via brute force with appropriately managed search trees. LLMs actually are not much better at this than other ML or search techniques; it's just that in practice, that's not what proof engineers have optimized for.<p>Building a sound specification, that as erichocean pointed out, would include measures to prevent nonce re-use, is a much more subtle and difficult thing. You can prove that software is correct with respect to a specification, but there is nothing beyond proving internal consistency, to verify that the specification itself is sound, complete, or appropriate. This is an open-ended problem, and one that humans have difficulty with. I don't think that any synthetic intelligence is likely to do better, because it can only do as well as the vetting of information provided to it, and it is very likely that this information will be flawed and incomplete. LLMs try to fill in the blanks with plausible things, based on their training. Even humans make assumptions. These assumptions are sometimes wrong.<p>Regarding proof automation, this is actually a double-edged sword. I can build systems today that will perform various optimization techniques to try to get further into a proof via tactic search, and will eventually converge on a solution. However, the tactics will be a mess, much like the 1600 pages of tactics in the OpenAI NS proof. A good proof engineer builds specifications and proofs that other humans can read and understand. Even the tactics are organized around what can be explained, so that these can be hand checked. If you're building proofs of software, you want auditors to be able to look at these as well as the specification to see if you are missing something, such as a nonce re-use policy.</p>
]]></description><pubDate>Tue, 17 Nov 2026 20:54:41 +0000</pubDate><link>https://news.ycombinator.com/item?id=50538046</link><dc:creator>nanolith</dc:creator><comments>https://news.ycombinator.com/item?id=50538046</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=50538046</guid></item><item><title><![CDATA[New comment by nanolith in "Formal Verification Is Not Verifiable"]]></title><description><![CDATA[
<p>It's not just a matter of competence: it's a matter of knowledge, experience, and tenacity. Currently, frontier model companies are trying to tackle the problem of their models writing potentially unsafe software by demonstrating that their models can build formal proofs. However, someone who lacks formal verification experience, the domain knowledge to make such software safe, or the understanding to combine the two into formal specifications will build bad proofs, because the formal specifications will be unsound. LLMs don't necessarily improve this outcome. An inexperienced engineer, with or without LLM assistance, is just as likely to not add a property to verify that nonces aren't re-used as the WiFi Alliance.<p>WPA2 wasn't designed by a single individual. It was designed by a committee of people including respected cryptographers and information security folks. They missed the fact that nonces could be re-used in the design, and they trusted the formal specifications that lacked a check on nonce re-use. It happens. Unfortunately, formal specifications tend to trap folks into a sense of complacency. Soundness is a hard problem, and if it's not solved, folks will make bad assumptions. "But, it's been formally verified..."<p>Could LLMs accelerate tactics and Curry-Howard level hole filling of specifications? Absolutely. But, they aren't likely to do much better than humans at building sound specifications. This is a difficult problem, for experienced humans with a narrow specialization in formal methods.</p>
]]></description><pubDate>Tue, 17 Nov 2026 04:04:33 +0000</pubDate><link>https://news.ycombinator.com/item?id=50527282</link><dc:creator>nanolith</dc:creator><comments>https://news.ycombinator.com/item?id=50527282</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=50527282</guid></item><item><title><![CDATA[New comment by nanolith in "Formal Verification Is Not Verifiable"]]></title><description><![CDATA[
<p>I can give a real-life example. WPA2 was formally verified at the protocol level, but the formal specification -- while reviewed by multiple humans -- was flawed, which directly led to the KRACK attack.<p>The Needham-Schroeder Public-Key Protocol failed to include the responder's identity in the protocol, which led to a man-in-the middle attack found via model checking. This is despite numerous proofs -- some even machine-checked -- of implementations against specification.<p>When cryptocurrencies had their formal methods moment a few years ago, there were numerous vulnerabilities and attacks found in cryptocurrency protocols despite claims of being formally verified, and despite much of this verification being published in Rocq, Lean, etc. If the specifications are unsound or flawed, then the implementations will also be. While in these cases, it's quite clear that the folks performing the formal methods work were likely inexperienced, I don't see how an LLM will create anything more sound.<p>Remember that an LLM is trained on publicly available information. It's not going to make a leap above and beyond what has been published openly, and much of what has been published with respect to security is related to student projects (e.g. "Let's build a formally verified AES implementation") or one-off applications, some of which, like WPA2 KRACK, have incomplete specifications.<p>This is a difficult problem that experienced proof engineers get wrong, after performing rounds of threat modeling and review.</p>
]]></description><pubDate>Tue, 17 Nov 2026 03:28:04 +0000</pubDate><link>https://news.ycombinator.com/item?id=50527039</link><dc:creator>nanolith</dc:creator><comments>https://news.ycombinator.com/item?id=50527039</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=50527039</guid></item><item><title><![CDATA[New comment by nanolith in "Formal Verification Is Not Verifiable"]]></title><description><![CDATA[
<p>Proofs are useful insofar as the formal specification is sound. The <i>problem</i> is that building a sound formal specification is the hard part, and it's not something that LLMs are going to be particularly good at. Yes, they can write a formal specification. But, is this formal specification sound? Is it usable? Is it applicable? Is it complete? This all requires human level reasoning and perhaps beyond to verify.<p>Once you have a sound formal specification, building proofs that software follows this specification is actually fairly straightforward. LLMs aren't doing any magic here.</p>
]]></description><pubDate>Tue, 17 Nov 2026 01:24:32 +0000</pubDate><link>https://news.ycombinator.com/item?id=50526200</link><dc:creator>nanolith</dc:creator><comments>https://news.ycombinator.com/item?id=50526200</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=50526200</guid></item><item><title><![CDATA[New comment by nanolith in "A renowned scientist, a deadly snakebite, and a diary that documented it (2025)"]]></title><description><![CDATA[
<p>I wouldn't call their rear teeth "fangs". I don't think they are even grooved like rear fangs. In colubrids, the venom is in their saliva, so even if you are cut by one of the front teeth, that can be enough to get envenomated. How much of a dosage you get really comes down to how much the snake "chews" on your hand, which mixes in the saliva and thus the venom.</p>
]]></description><pubDate>Tue, 10 Nov 2026 03:25:52 +0000</pubDate><link>https://news.ycombinator.com/item?id=50435697</link><dc:creator>nanolith</dc:creator><comments>https://news.ycombinator.com/item?id=50435697</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=50435697</guid></item><item><title><![CDATA[New comment by nanolith in "A renowned scientist, a deadly snakebite, and a diary that documented it (2025)"]]></title><description><![CDATA[
<p>Something like this likely went through his head. The problem with exotic snakes is that if they are venomous, the likelihood of there being antivenom obtainable within the time that it could serve you any therapeutic use is pretty low. That's true even today. In his case, he was probably documenting symptoms to be thorough at first, and then when he suspected that he had been envenomated, he did the calculus and realized he was already dead.<p>Envenomation is not necessarily a death sentence. It comes down to immune system response and dosage.<p>That being said, even today, people foolish enough in the US to own black mambas or cobras are taking significant risks. If bitten and envenomated, they would likely die before antivenom can be air lifted from whatever rare reserves may exist to their location. If one is going to own such snakes, one should be willing to spend six figures on many doses of one's own antivenom, which is only good for 2-5 years and must be replenished, or, to live near a location where such antivenom is stockpiled and be ready to pay to buy replacement antivenom afterward. The assumption should always be that if one owns a venomous snake, it is a question of when, and not if, one will be bit.<p>I have had a few tame (non-venomous) reptiles over the years. Very gentle things, but sometimes, they bite. The reasons why are numerous: They get scared. They aren't feeling well. They are trying to communicate something. Regardless, they will bite. Getting bitten by a 7 foot male iguana with beefy jowls is not fun. Thankfully, he just nipped me. I still had to clean out the wound and butterfly it.</p>
]]></description><pubDate>Tue, 10 Nov 2026 03:21:14 +0000</pubDate><link>https://news.ycombinator.com/item?id=50435667</link><dc:creator>nanolith</dc:creator><comments>https://news.ycombinator.com/item?id=50435667</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=50435667</guid></item><item><title><![CDATA[New comment by nanolith in "A renowned scientist, a deadly snakebite, and a diary that documented it (2025)"]]></title><description><![CDATA[
<p>There are a few species of colubrids that are venomous. What is surprising to most people is that the common garter snake is mildly venomous. The venom doesn't really affect humans like their more venomous cousins, but if their bites do manage to break the skin enough to mix in their saliva, it contains venom that has a mildly neurotoxic effect. This can cause swelling, bruising, and numbness in the affected area. Such a bite is often described as a "bee sting".</p>
]]></description><pubDate>Tue, 10 Nov 2026 03:01:49 +0000</pubDate><link>https://news.ycombinator.com/item?id=50435559</link><dc:creator>nanolith</dc:creator><comments>https://news.ycombinator.com/item?id=50435559</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=50435559</guid></item><item><title><![CDATA[New comment by nanolith in "C++26 Disapproved"]]></title><description><![CDATA[
<p>> I don't think that contracts would fundamentally change this.<p>On their own, no. What contracts provide are annotations for how the programmer expects the code to behave, which can be verified by model checkers or automatic theorem provers. These can already verify memory safety properties; borrow checking only does a subset of what a model checker can do. To scale model checking up so it can work on a large codebase, compositional verification is required. Contracts enable compositional verification, which in turn allows developers to write code safer than what is possible with vanilla Rust or Java.<p>I do this today with C. The model checked C I write is safer than software written in Rust without a model checker. It is memory safe, and it is verified to work within the specification that I have designed. As far as the specification is correct, it is correct.<p>We can't rewrite the world in Rust. There are many billions of lines of code in C and C++ that aren't going away. Instead, we need to find ways of making this code safe with as little change to it as possible.</p>
]]></description><pubDate>Wed, 04 Nov 2026 23:25:33 +0000</pubDate><link>https://news.ycombinator.com/item?id=50372867</link><dc:creator>nanolith</dc:creator><comments>https://news.ycombinator.com/item?id=50372867</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=50372867</guid></item><item><title><![CDATA[New comment by nanolith in "C++26 Disapproved"]]></title><description><![CDATA[
<p>I did a talk on this at BSDCan 2026:<p><a href="https://www.bsdcan.org/2026/timetable/timetable-Model-Checking-in.html" rel="nofollow">https://www.bsdcan.org/2026/timetable/timetable-Model-Checki...</a><p>That link has the slides and some example code. There's also a live stream on YouTube.<p>Regarding features I miss from C++, I like the concept of generics. I don't like the implementation in C++. I also find C's _Generic facility to be limited, especially when building containers that perform hygienic type erasure. This feature isn't enough for me to go back to C++ on its own, but it is something I'm exploring in a new language I'm writing.</p>
]]></description><pubDate>Wed, 04 Nov 2026 21:03:15 +0000</pubDate><link>https://news.ycombinator.com/item?id=50371487</link><dc:creator>nanolith</dc:creator><comments>https://news.ycombinator.com/item?id=50371487</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=50371487</guid></item><item><title><![CDATA[New comment by nanolith in "C++26 Disapproved"]]></title><description><![CDATA[
<p>Any language is viable if appropriate engineering is applied to it. There are many billions of lines of code in C and C++. This software needs to be made safer, and it is not possible nor viable to rewrite it all into a different language. Hence, we need to dig into CS and PL theory to find ways to fix this software that does not incur significant investment, does not require retraining software developers in a new language, and does not result in a "big rewrite in the sky" style project.<p>Contracts are annotations, much like types are. What makes contracts powerful is the tool that examines this annotation, as is the case with types. A type checker, such as an H-M type checker, can only perform limited checks. It's possible to use a dependent type checker with dependent types, but this is undecidable, and it requires a proof assistant and human guided tactics to resolve. In practice, this is expensive, and when automation such as LLMs are used, one currently gets tactic soup that is difficult to understand, which defeats the purpose.<p>A model checker, such as CBMC or ESBMC, can work with contracts to verify specification that would be difficult to verify without contracts. Model checkers can already verify memory safety and even the absence of memory leaks across an entire program. However, model checking grows exponentially expensive as we add more code to be verified. Contracts give us the ability to perform compositional verification, which allows us to verify codebases into the millions of lines of code or larger by breaking down this verification into many small model checks, stitching these together with contracts and invariants. Contracts and invariants complement type checking and significantly extend it. It's possible to use contracts and invariants to add these checks to an untyped language or a minimally typed language such as C. If my precondition includes the data invariant, "property_valid_widget(x)", then effectively, this also type checks x. This works even if I've completely erased the type and later recast it.<p>The "real world" doesn't currently have a solution for reducing general software safety issues -- which goes far beyond memory safety -- other than formal methods. Practical and efficient ways to formally verify software is within our reach, and is already being done with other languages. I do this today with C / CBMC using contracts and invariants. I get memory safety, specification safety, and a guarantee of no memory leaks. This can also be done with C++, Rust, Java, and other languages using similar techniques. While it is true that Rust and Java both have basic memory safety in place, they also both can harbor vulnerabilities that could be resolved with function contracts and model checking.<p>Contracts are more than useful; they give visibility of developer intent to model checkers and similar tools. This visibility makes software significantly safer than borrow checking or type checking can alone.</p>
]]></description><pubDate>Wed, 04 Nov 2026 20:56:58 +0000</pubDate><link>https://news.ycombinator.com/item?id=50371401</link><dc:creator>nanolith</dc:creator><comments>https://news.ycombinator.com/item?id=50371401</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=50371401</guid></item><item><title><![CDATA[New comment by nanolith in "C++26 Disapproved"]]></title><description><![CDATA[
<p>While I can understand that C++ contracts were met with controversy, contract annotations scoped at analysis time that can be verified by external tools, such as static analyzers, model checkers, or automatic theorem provers, are incredibly useful.<p>I put together an alternative function contract and invariant mechanism in C using CBMC and custom macros that effectively allows me to perform formal methods in C using compositional verification. The reason why I chose C is because of its relative simplicity and relative ease of building tooling around it. C++ contracts provide some feature parity, and would let me take advantage of some of the features in C++ relative to C.<p>I hope that the contract proposal is workshopped and simplified so it can be proposed again for a future version. Its current form is unsuitable, but it deserves a second chance with a simpler implementation. Contracts would narrow the safety gap between C++ and languages such as Ada / SPARK.</p>
]]></description><pubDate>Wed, 04 Nov 2026 05:21:24 +0000</pubDate><link>https://news.ycombinator.com/item?id=50361756</link><dc:creator>nanolith</dc:creator><comments>https://news.ycombinator.com/item?id=50361756</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=50361756</guid></item><item><title><![CDATA[New comment by nanolith in "AlpineBSD"]]></title><description><![CDATA[
<p>Pragmatic in that it balances the pro- and anti- LLM sentiments. There are plenty of other valid reasons to take a hard stance against LLMs.<p>I don't use them for open source projects I maintain.</p>
]]></description><pubDate>Thu, 29 Oct 2026 00:21:48 +0000</pubDate><link>https://news.ycombinator.com/item?id=50282808</link><dc:creator>nanolith</dc:creator><comments>https://news.ycombinator.com/item?id=50282808</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=50282808</guid></item><item><title><![CDATA[New comment by nanolith in "AlpineBSD"]]></title><description><![CDATA[
<p>Regardless of how you feel about using LLMs or using products that are developed with LLMs, it is a good idea to have an ecosystem of open source projects with differing levels of LLM involvement, including pristine software written entirely by humans.<p>The pragmatic argument for hard no-LLM projects: if models are to be useful, they need good input. Hand-written software that has been carefully audited is free from the kinds of feedback errors that will eventually weaken LLM code generation. Otherwise, a bad pattern gets copied. In the next generation, this bad pattern is seen a bit more often as stochastic models converge on it and more open source code adopts it. This is reinforced in the next generation and it becomes a common pattern. Then, in the next generation, this pattern is seen all over. This could be inert "non-coding DNA" like weird naming conventions or pointless comments. Or, it could be bad edge cases that become commonly exploitable.</p>
]]></description><pubDate>Wed, 28 Oct 2026 18:06:53 +0000</pubDate><link>https://news.ycombinator.com/item?id=50278235</link><dc:creator>nanolith</dc:creator><comments>https://news.ycombinator.com/item?id=50278235</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=50278235</guid></item><item><title><![CDATA[New comment by nanolith in "OpenBSD 8.0"]]></title><description><![CDATA[
<p>The best place to go for curated patches is here. You can customize these or roll your own once you have a chance to examine the source code. dwm is very simple.<p><a href="https://dwm.suckless.org/" rel="nofollow">https://dwm.suckless.org/</a></p>
]]></description><pubDate>Tue, 20 Oct 2026 20:43:25 +0000</pubDate><link>https://news.ycombinator.com/item?id=50172400</link><dc:creator>nanolith</dc:creator><comments>https://news.ycombinator.com/item?id=50172400</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=50172400</guid></item><item><title><![CDATA[New comment by nanolith in "OpenBSD 8.0"]]></title><description><![CDATA[
<p>That should be the case, but you'd be surprised how many people just run stock dwm. I don't get it.<p>All of the "suckless" distributions beg to be patched.</p>
]]></description><pubDate>Tue, 20 Oct 2026 20:18:39 +0000</pubDate><link>https://news.ycombinator.com/item?id=50172067</link><dc:creator>nanolith</dc:creator><comments>https://news.ycombinator.com/item?id=50172067</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=50172067</guid></item><item><title><![CDATA[New comment by nanolith in "OpenBSD 8.0"]]></title><description><![CDATA[
<p>By default, OpenBSD uses FFS / FFS2. There is an effort in place to port GeFS (from 9front) to OpenBSD. It's unlikely that ZFS will be ported to OpenBSD, due to licensing incompatibilities. For the same reason, btrfs is also unlikely. That's why I run FreeBSD on my big server, and OpenBSD on my laptop and other edge devices. I don't really have any issues running FFS on a laptop; it seems overkill to run anything more advanced than that.<p>I'd recommend taking a look on forums to see what other folks are running. If it's a modern Lenovo with integrated graphics or an AMD GPU, it will be supported before others. OpenBSD folks tend to use Lenovos. My best recommendation is to pick a laptop that a core maintainer is using, unless you feel comfortable making your own patches. They have AMD GPU support via DRM from Linux. Intel graphics typically works alright.<p>OpenBSD works well with relatively recent versions of Chromium and Firefox. That being said, they are on a six month release cycle. The Chromium port can fall behind if you stick to -stable or releases. Building Chromium or Firefox from source is... well, I have a 2012 laptop, so that's not something <i>I</i> am going to do. Regardless, you'd need to be pretty comfortable with applying OpenBSD specific patches to one of these browsers, which isn't always obvious, especially since they are moving targets.<p>If you're used to being on a rolling release Linux, this will be a bit disorienting. But, in my opinion, it's significantly more stable and better thought out.</p>
]]></description><pubDate>Tue, 20 Oct 2026 09:54:50 +0000</pubDate><link>https://news.ycombinator.com/item?id=50163626</link><dc:creator>nanolith</dc:creator><comments>https://news.ycombinator.com/item?id=50163626</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=50163626</guid></item><item><title><![CDATA[New comment by nanolith in "OpenBSD 8.0"]]></title><description><![CDATA[
<p>I use a custom dwm.</p>
]]></description><pubDate>Tue, 20 Oct 2026 08:56:12 +0000</pubDate><link>https://news.ycombinator.com/item?id=50163176</link><dc:creator>nanolith</dc:creator><comments>https://news.ycombinator.com/item?id=50163176</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=50163176</guid></item><item><title><![CDATA[New comment by nanolith in "OpenBSD 8.0"]]></title><description><![CDATA[
<p>Don't forget: doas syspatch. They tend to find some minor issues rather quickly after release.<p>Since I maintain my own custom patch set under OpenBSD, this is also usually when I need to vendor in the new release and update all of my patches.</p>
]]></description><pubDate>Tue, 20 Oct 2026 06:23:38 +0000</pubDate><link>https://news.ycombinator.com/item?id=50162067</link><dc:creator>nanolith</dc:creator><comments>https://news.ycombinator.com/item?id=50162067</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=50162067</guid></item><item><title><![CDATA[New comment by nanolith in "OpenBSD 8.0"]]></title><description><![CDATA[
<p>I've used OpenBSD as a laptop daily driver for nearly 20 years. It's small. It remains mostly consistent between updates. In fact, it's so stable that I barely notice changes when I upgrade until I go hunting for them.<p>The Lenovo laptop I use as my travel laptop and console display is a 2012. It still runs OpenBSD just fine.</p>
]]></description><pubDate>Tue, 20 Oct 2026 06:20:05 +0000</pubDate><link>https://news.ycombinator.com/item?id=50162039</link><dc:creator>nanolith</dc:creator><comments>https://news.ycombinator.com/item?id=50162039</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=50162039</guid></item><item><title><![CDATA[New comment by nanolith in "U.S. Supreme Court to review 1868 federal ban on home distilling of liquor"]]></title><description><![CDATA[
<p>I'd say that it is actually fairly easy to poison oneself brewing different kinds of alcohols. It is a risky activity. So is driving. So is making fireworks. So is chemistry. So is making cheese, pickles, sauerkraut, and canned goods. People die of botulism every year because they don't follow basic safety procedures when canning, or they eat canned goods that someone else improperly prepared.<p>That doesn't mean that one shouldn't be allowed to do these things. It means that we should provide appropriate training and, in some jurisdictions, reasonable / non-discriminatory licensing for those who wish to do these things.<p>When it comes to distillation, the rules are pretty straight-forward:<p>Keep a log book. Use quality equipment. Measure temperatures. Learn to discard heads and tails. Use appropriate ventilation and fire safety protocols. Purchase qualitative test equipment to verify that the product does not contain harmful contaminants. Licensing is a great way to ensure that people know about these things and follow them. A blanket ban actually makes it more likely that people who violate this ban to distill alcohol will poison themselves or others.</p>
]]></description><pubDate>Tue, 20 Oct 2026 05:52:57 +0000</pubDate><link>https://news.ycombinator.com/item?id=50161856</link><dc:creator>nanolith</dc:creator><comments>https://news.ycombinator.com/item?id=50161856</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=50161856</guid></item></channel></rss>