8 ms·

Why don't people use formal methods? (2019)

128 points by Thom2503 2mo ago

taylorbuley 2mo ago
Where formality, when right, still goes wrong: 0) premature but fitting; 1) settled but situationally mismatched; 2) same formal token, different external meaning.
s_dev 2mo ago
https://blog.janestreet.com/formal-methods-at-jane-street-index/ https://blog.janestreet.com/formal-methods-at-jane-street-in... I thought this article from Jane Street makes a nice complimentary pairing.
- exogenousdata 2mo ago
  And it’s not just blogs. They’ve got an open job posting [0] for a ‘Formal Methods Engineer’. [0] - https://www.janestreet.com/join-jane-street/position/8585303002/ https://www.janestreet.com/join-jane-street/position/8585303...
- rstuart4133 2mo ago
  And this pairs nicely with Jane Street's observation that agentic coding changes the formal proof equation: https://news.ycombinator.com/item?id=49064854 https://news.ycombinator.com/item?id=49064854 Formal proofs of code are almost beyond the capabilities of the best human programmers (3.7 lines per day!), but LLMs can bash out code at an amazing pace. It's often crap, sadly, but the proof they are bashing out is the hard bit. If possible at all, the task is EXPTIME. Verifying the proof is only P, so when it's wrong you tell the LLM to do it again. A stable agentic loop is what makes it possible. The results in the article I linked to speak for themselves.
SCdF 2mo ago
In most industries that need software made for them it's hard enough to get people to care about spending enough time on informal methods let alone formal ones. I simply don't think most of the industry has had the breathing room and respect for engineering for this pattern to develop.
- another_twist 2mo ago
  I think its also about tolerance for failure. For software that must not fail or where reliability commands a premium you would be wise to invest in formal methods. Core systems at aws for example. For throwaway CRUD code its just easier to try iterations on the problem and call it a day. Its not about respect just RoI.
- forinti 2mo ago
  I think programmers in general do not give much thought to the level of engineering required for a task. Mostly, there's too little, but there are many cases when there's too much. I see people writing tons of tests for corporate software that will be used by a couple of people and will have to be updated regularly anyway. Building a hut is not the same as building a skyscraper, but we don't really have guidelines for different software projects. No methodology I've ever seen distinguishes types of projects by complexity.
  - epolanski 2mo ago
    I know few 100% unit test coverage, strictest typing to encode invariants fellas who's app is consistently broken and product makes less money than the bakery in my village.
unprovable 2mo ago
This blog is actually very useful... There's also the flip side, possibly due to the expense (technically, intellectually, and emotionally), where "IT'S FORMALLY VERIFIED!!" has become some marketing code for "it's safe, secure, and PFAS free..." - just because something is formally verified, doesn't mean it's secure or fit for purpose. It usually just means it conforms to a given spec "and that's that..."
asxndu 2mo ago
I think it's the culture is software engineering. In a food delivery app/social network it seems like a waste of time to use formal methods. When designing software for aircraft, pacemakers, fintechs, cryptography and DeFi protocols there is a bit of value for formal methods. The problem is that often, people with the food app/social network culture are hired to build DeFi protocols. Which explains why so much money is being stolen form DeFi protocols of late. So why people don't use formal methods. - 95% of the time, the stakes are low - 5% of the time, the engineers don't understand the value of formal methods. Leslie Lamport once joked that if software developers were architects, they would first build a skyscraper and then later draw the blueprint.
- antonvs 2mo ago
  I enjoyed this quote from the article, which concisely summarizes the first part of the above comment: > “website isn’t airplane!!!”
- kalcode 2mo ago
  Also you can write a perfect specification get into implementation and have to step back and redesign. Software is fast to iterate and test that a lot assumptions can be proven by actually writing the code. Software is closer to gardening or painting. We discover a lot through practice and writing code. Then we can often write more formal specifications. But formal method is impractical for most software upfront, and instead is likely used for more serious runtime failures or cost of life. That's just my two cents.
vslira 2mo ago
Speaking for myself (and I bought Hillel's recently published Logic for Programmers): It's not clear to me which formal method I should use. I'm certain the answer is "there's a different best one for each situation", but I don't want to know one for each problem I'll face. I'd rather have a definitive answer to what is the second best for all situations, similar to how we can answer "python" to that question when the question is about general programming
- antonvs 2mo ago
  > similar to how we can answer "python" to that question when the question is about general programming An ironic claim in the context of formal methods.
  - dahart 2mo ago
    Out of curiosity, why’s that? I don’t know formal methods nor the relationship to python.
    - mrkeen 2mo ago
      The most widely available, useful, and best-bang-for-buck formal method is using a good type system.
ndriscoll 2mo ago
We do. It's called a type checker. Every "formally verified" system is going to be partially verified. e.g. you might prove your sort procedure sorts, but did you prove its complexity? Under a cost model for integer compares or a cost model for page fetches? Or both? Multi-layer cache page fetch costs? How well you verify just depends on how well you decide to model the problem. Different type checkers have different modeling features. This is a more useful perspective; it's not "we do/don't use formal methods," but instead "how can I more precisely model my domain?" Helpfully, if you model your domain well, code tends to be obvious/write itself.
- yoshuaw 2mo ago
  One of my favorite quotes on this topic is: "Type systems are just the parts of formal verification we've figured out how to make fast."
  - honr 2mo ago
    Thankfully this is no longer strictly true. So, I think the quote needs a slight adjustment, "Type systems and $THING are just ...", but $THING is not very well defined yet. Between "linters", and other relatively fast AST-based rule enforcers, some of which looking at higher order behavior, I think we now have an amalgamation of formally verified concepts that we can consider fast enough and sufficient exercised in practice that we are ever closer to widespread formally and dependably verified software. Still, it's a long journey, and academic formal verification would always be, by design, a few steps ahead of what the industry can do efficiently in practice.
    - Taikonerd 2mo ago
      The field really needs more popularizers. I mean people or projects who can do "advertising" like, "if you add our linter to your CI/CD pipeline, you'll never have X class of bug ever again!"
  - rrook 2mo ago
    given your experience on the topic, i'm curious: do you think that the reason we haven't figured out how to make other parts of formal verification fast is that, in general, programming languages expose each individual machine operation in the code, so the verification surface area is the combinatorial set over that? i've been working on a low level high opinion language, and its verifications are able to be checked in an extremely tight loop, largely because of the structure of the language itself.
IshKebab 2mo ago
I think everyone knows the answer already - it's too hard to be worth it for most problems. The article doesn't disagree with that and was a good read anyway. Don't skip it because you already know the answer. IMO the reason is way more on the "it's too hard" side than "it isn't worth the effort". Formal verification is extremely common in the silicon hardware design world, despite its extreme cost (the tool licenses cost on the order of $100k per seat, as far as I can tell). And in this domain bugs are really expensive. But I think it would be used in spite of that simply because it is an order of magnitude easier than software formal verification. I don't know if there is any solution to that. Software itself is an order of magnitude (or more) more complex than hardware... I think the author's suggestion of partial verification is the way to you. You're not going to formally verify your GUI but you could formally verify your LZ4 decoder. Maybe.
- win311fwg 2mo ago
  Formal verification is also extremely common in the software design world, to be fair. Most programming languages in use have at least a primitive type system and even those that historically didn't are gaining them (e.g. Typescript, Python gradual typing, etc.) The question is, as always, to what degree do the returns start to diminish. The Rust crowd laughs at Go's level of formal verification and says that their level of formal verification is the right level, but then the Lean crowd laughs at Rust's level of verification and says that their level of formal verification is the right level. The universe laughs at all of them. For crowds so concerned about mathematical proofs, it is funny that they end up right back at gut feeling.
  - IshKebab 2mo ago
    It's a continuum... but I would say even Rust's type system is not in the realms of "formal verification". I think you need at least some kind of refinement types so you can say "an integer between 1 and 10" before you can stake even a vague claim to "formal verification". So I don't think you can say it's common in the software world.
    - win311fwg 2mo ago
malisper 2mo ago
I recently came across a use case where formal methods were incredibly helpful. I've been rewriting Postgres in Rust and am currently focusing on correctness. The biggest challenge is that there's so much surface area to cover. Postgres has over 3000 user-facing functions, ranging from regular expression matching to JSON iteration to computing the gamma function. About half of these functions are simple pure functions. Of the 3000 functions, I've been able to formally verify that the Rust behavior is identical to the Postgres C behavior for over 1000 of them. In the process, I found 4 different Postgres bugs. All of them would not be triggered under ordinary usage, but one, if triggered, would corrupt your database. I think why formal methods works well for this is I'm testing a large number of small to medium self-contained pieces of code. For each of them the specification is simple: does postgres_fn(args) == pgrust_fn(args). I've been using Kani[0] which works across both Rust and C code so the proofs are based off the actual code and not a translation of the code to another language. If you want to check out what all the verification look like, you can see them here[1] [0] https://github.com/model-checking/kani https://github.com/model-checking/kani [1] https://github.com/malisper/pgrust/tree/main/proofs https://github.com/malisper/pgrust/tree/main/proofs
- excitedrustle 2mo ago
  > I found 4 different Postgres bugs. Bugs in the upstream Postgres C implementations? Did you report them or submit patches? I'm curious to see what you found!
  - malisper 2mo ago
    Yep, I did submit bug reports. This was on Tuesday. I don't see a public copy of the mailing list that has my bug reports yet. The four bugs were: 0) When parsing a macaddr[0], Postgres uses sscanf with %x. %x can wraparound. This means SELECT '10000000aa:bb:cc:dd:ee:ff'::macaddr; will return aa:bb:cc:dd:ee:ff. 1) When parsing a tid[1], Postgres uses strtoul. The return value of strtoul is different across platform for the empty string. This means on some platforms Postgres SELECT '(,5)'::tid; will error and others will accept it. 2) Postgres missed an overflow check in it's cash type[2]. When running SELECT '-92233720368547758.08'::money / (-1)::int8; some platforms will error and other's will return the MIN value. Postgres does check for this for some of the other cash related functions, but it missed it for one of them. 3) When hashing the "char" type Postgres will cast a char to an integer[3]. On some platforms char is signed and on others it's unsigned. This means the hash of a char can be different depending on the platform. If you are using a hash index or hash partitioning on a char and move your DB from x86 to arm, the hashes will differ and your index/partitioned tables become corrupted. Note that this is special char type that you have to refer to by "char" that is separate from the typically used CHAR(n) type which is what you typically use, hence this would never come up under real usage. The common pattern with all of these is they rely on C behavior that differs across platform (integer overflow, char signedness, strtoul). Rust is better about having more consistent behavior across platforms so these cases get flagged when the Rust code and the C code differ. [0] https://github.com/postgres/postgres/blob/REL_18_3/src/backend/utils/adt/mac.c#L71-L81 https://github.com/postgres/postgres/blob/REL_18_3/src/backe... [1] https://github.com/postgres/postgres/blob/REL_18_3/src/backend/utils/adt/tid.c#L75-L81 https://github.com/postgres/postgres/blob/REL_18_3/src/backe... [2] https://github.com/postgres/postgres/blob/REL_18_3/src/backend/utils/adt/cash.c#L155-L165 https://github.com/postgres/postgres/blob/REL_18_3/src/backe... [3] https://github.com/postgres/postgres/blob/REL_18_3/src/backend/access/hash/hashfunc.c#L47-L51 https://github.com/postgres/postgres/blob/REL_18_3/src/backe...
dirkc 2mo ago
Isn't the problem with formal methods that it isn't clear whether or not most of the useful code we use are actually formally verifiable? The article mentions NP-complete, but is it actually a solvable problem in general? > For extremely restricted cases, like propositional logic or HM type-checking, it’s “only” NP-complete.
- angry_octet 2mo ago
  No, lots of problems can be expressed in a way that can be verified. But complete verification of an existing implementation is essentially impossible. That doesn't mean that formal techniques are not useful, far from it. For example, AWS uses a formally specified model to verify if an implementation is correct by looking at the telemetry. See e.g. https://p-org.github.io/P/advanced/pobserve/pobserve/ https://p-org.github.io/P/advanced/pobserve/pobserve/ This isn't something you could meaningfully do with standard testing techniques, and it very compositional, you can do it piece by piece.
the__alchemist 2mo ago
My 2c I don't understand any of the material I've read describing them. What I do understand makes them sound like it will be a load of work for questionable benefits. If I end up writing safety-critical code. (Aerospace firmware, big robots etc), I will get over this hump and learn them. If not, I am not yet compelled; rather intimidated. Maybe this is like Quaternions, that are actually very easy and useful, but suffer from confusing descriptions. Or maybe more like Monads, which are actually very abstract, and may not be suitable unless your the sort who understands Mathematician style mathematics. More to the point: I'm not even sure how I would get started and evaluate them tacitly. Of particular confusion: Does formal verification lead to a strange-loop style or "It's verification all the way down" scenario, where you are shifting the correctness from the original code to the verification? Then must verify the verification ad-infinitum? (This is almost certainly wrong, but I don't grasp why) The big question I ask: "Would I rather have a code base with formal verification, or one in which all the time and effort used by add that were spent using and testing the software in a practical way; or code reviewing it"
- Taikonerd 2mo ago
  > Does formal verification lead to a strange-loop style or "It's verification all the way down" scenario, where you are shifting the correctness from the original code to the verification? Then must verify the verification ad-infinitum? IANA formal methods guy, but my understanding is: yes, you're shifting the correctness burden from the code to the spec. So why is that better? Because the spec is much shorter and more focused -- it strips out all of the implementation details. It's bad to say "you have to trust this 100,000 line program." It's much better to say "you have to trust this 100 line spec, and the code that verifies it."
  - the__alchemist 2mo ago
    That is a great explanation!
StilesCrisis 2mo ago
Because there is almost never a business need? Most programs don't need to be rigorously perfect. If they did, LLMs wouldn't be as popular as they are right now. If you're dealing with medical equipment or space flight, maybe there's a need. But usually the goal is to make errors _inexpensive_ to find and fix, not theoretically impossible.
- eru 2mo ago
  The ironic thing is that LLMs are what will make formal methods feasible. First: LLMs find so many bugs and security holes in software right now. So you pretty much have to prove your stuff correct, if you don't want to get hacked into. Second: LLMs make it much easier to apply formal methods. Just ask Claude to prove your stuff in Lean or whatever, no PhD required anymore.
- akshayshah 2mo ago
  I'm not sure how to think about what you mean by "almost never." If most commercial software is web frontend + monolithic app code + relational DB, then you may very well be right. That doesn't quite match my professional experience, though - there are so many companies building databases, message queues, filesystems, and similar infrastructure. Sometimes they're internal projects, and sometimes they're commercial products. I've always felt that those systems would benefit from formal methods, since they're usually trying to provide strong guarantees to the application code on top.
  - StilesCrisis 2mo ago
    Almost all software is internal "make the business run" software that we never see, or web pages. Very very few engineers would even consider making a new message queue. The crowd here is different than most :)
teiferer 2mo ago
To me, "this returns sorted lists" illustrates the crux. You may know exactly what you want, and you may have a reasonably fast and cheap way to verify your code against a formal specification. But the formal specification needs to come from somewhere and for any non-trivial program its complexity is going to be in the same order of magnitude as the code implementing it. So we are back to writing "code" (which is what a formal specification is) that needs to be checked against what we actually want. And that "code" needs .. a test? Hard thinking? A formal verification itself? Don't believe me that this is hard? Back to "this returns sorted lists". The promise of formal verification is that whatever implementation I throw at the verifier, as long as it passes the check, I'm happy (assuming that I can also encode things like running time and resource use). Now imagine a program that always returns the empty list. It satisfies "this returns sorted lists" trivially but is not at all what we want. The formal spec has a bug. Such issues can be subtle in larger projects and no amount of model checking or SMT solvers can guard you against a bug in that "code". Don't get me wrong, it can be incredibly useful. But it's not the silver bullet that some proponents make it out to be. It's another tool next to testing, not instead of it. (The whole "testing can only prove the existence of bugs, not their absence, that's why we should use formal verification instead" is just misguided at best and propaganda at worst.)
- bluGill 2mo ago
  I have a deeper problem. When I'm calling sort() it is useful that it returns a sorted list. However my program rarely has sorted lists of any sort in any requirement. My requirements are around the features my users care about. Sure the list of employees that I need to display needs to be sorted (sometimes by hire date, sometimes by title, sometimes by name - and often combinations of the above), but there are a lot of things I'm doing with that list that are not sorting.
  - teiferer 2mo ago
    In which way is that a "deeper" problem? What you are doing with that data can also be expressed as a formal spec. Sorting is just used as an example everywhere because everybody knows exactly what we are talking about without having to explain a lot, it has a somewhat easy solution space and everybody has implemented some form at some point, likely in school, for the same reasons . Of course real world software is more complex that that but that's not the point.
tombert 2mo ago
I've been a big nerd for formal methods for quite awhile, and have been broadly unsuccessful in getting employers onboard. I have pretty cynical opinions as to the "why" of this, largely involving the fact that the vast majority of software engineers refuse to learn anything that they weren't explicitly taught in college, but regardless of the reason whenever I have tried proposing TLA+ in the past, people will nod along and wait for me to stop talking. I've had several managers say "they'll look into it", which was such an obvious lie that I don't know why they even bothered. I've "snuck in" TLA+ usage a few times. I gave up on getting anyone else to use TLA+, but as I've gotten more senior-level, I have been given a fair bit more leeway on how I approach projects and as such I have been able to budget myself a day or two to model some of the less-obvious bits of concurrency. All that said, I have had some luck with designing stuff with TLA+, then feeding the spec into Claude and getting that to implement the actual executable code. Maybe I'll be able to convince an employer that's a good use of time now.
- plastic-enjoyer 2mo ago
  > I have pretty cynical opinions as to the "why" of this, largely involving the fact that the vast majority of software engineers refuse to learn anything that they weren't explicitly taught in college, but regardless of the reason I think it's not only SWEs, but general persons that goe to college primarily to get a job, without having a natural curiosity for things.
  - tombert 2mo ago
    Probably true, I've just only ever worked in the software engineering world so I cannot speak about anything else.
- epolanski 2mo ago
  Software engineers are rarely engineers at all, and pretty much never know anything about computer science.
  - tombert 2mo ago
joelthelion 2mo ago
I would say the tooling plays a part. Where are the go-to open source solution that a beginner can turn to without too much research?
poly2it 2mo ago
For me, I wish the systems languages I am interested in could couple with legible verification systems, but alas, the world of formal methods seems disjoint. The only way to get a satisfactory development experience seems to be to learn Lean.
- Jtsummers 2mo ago
  > The only way to get a satisfactory development experience seems to be to learn Lean. Or SPARK, if you want to stick to systems languages.
dcminter 2mo ago
Pretty much every job I've had has involved integrating with highly imperfect, changeable, and inaccurately implemented (and barely documented) third party APIs. That's where most of the work went and I don't see formal methods improving the situation any time soon.
appplication 2mo ago
(Edit: replied to wrong comment)
deleted 2mo ago
[deleted]
taybin 2mo ago
I would love to see an example of a proof for something like a text editor. How can people be expected to do this when the examples are always trivial toys, like array sorting? Show me a formal proof of something that in the trenches programmers can copy from. A proof of a basic todo list or something like that.
- bluGill 2mo ago
  That is always my problem too. I can see how to prove sort, if I was writing the standard library for my language I might do that (it is hard, but I hope whoever wrote my library did). However sort is already in my library. I'm writing code that does things much harder to write into a spec.
- warkdarrior 2mo ago
  My guess is that the formal spec for a basic TODO list app is the same size as the source code of the app itself.
  - antonvs 2mo ago
    I would not be even slightly surprised if it were larger.
- mrkeen 2mo ago
  > A proof of a basic todo list or something like that. Just using a verb here would be a first step toward rigorous thinking. A proof that a todo list does what?
  - taybin 2mo ago
    To-does. Just like how a butler buttles.
    - antonvs 2mo ago
      Excuuuuuse me, I believe that should be to-dos.
kansface 2mo ago
Has anyone been experimenting with AI and formal methods - verification, proofs, or anything else? I've been thinking about this space quite a bit lately. For sufficiently interesting AI generated software, AI is also incapable of reviewing it - possibly for the same reason that humans are. AI ought to be able to adopt the formal methods humans have used to work around the inability to verify something just by looking at it hard. If the cost of adoption is what stopped us, thats no longer an issue.
- SebTardif 2mo ago
  [flagged]
1970-01-01 2mo ago
When I interviewed at AWS, I asked this question directly to their formal methods expert. Her response was two-fold: 1. All our code changes too much, we wouldn't be able to formalize it before it needed to change. 2. We already did this where we could, you just don't see it. I didn't get the job and remain very skeptical on both answers. I think they just didn't have enough power internally to change the move fast and break everything culture for the better.
- antonvs 2mo ago
  Why are you skeptical on point 1? For anything more complex than standard static type checking[], they're almost certainly correct. [] or, say, Haskell-level type checking. Which admittedly, AWS is not doing.
fauigerzigerk 2mo ago
"Much of this is a consequence of designs are not code. With most design languages, there is no automatic way to generate code" Maybe now there is, but I don't know how good LLMs are at using these relatively obscure (at least to me) design languages.
Merkur 2mo ago
Interesting read, thank you. I share your goal, and I think with AI- coding proving code right has become more relevant than ever. What prevents that we, just move the goal post? Moving the bug from code to spec? The spec must always be simpler and more easily to understand and debug than the code. But in praxis that means it can’t be fully specific in most of the use cases?
wduquette 2mo ago
I was exposed to Z notation in the late 80's, and could not for the life of me see how to apply to my work as a junior programmer. But the distinction the OP makes between Design and Code Specification was lost on me then (and, I think, on the folks I knew who were looking at Z); and the OP indicates that Z is aimed at Design Specification. As a junior programmer, it's no wonder it was lost on me.
scrubs 2mo ago
A little self promotion: for a way to see how to use TLA as a formal method see: https://news.ycombinator.com/item?id=48287718 https://news.ycombinator.com/item?id=48287718 I give a comprehensive introduction to formal methods without assuming background with a constant emphasis on examples, and using the tool.
deterministic 2mo ago
People do use formal methods. Type checking is a simple form of formal methods. Some languages have type systems that are advanced enough to prove code correct (LEAN/Agda/...) Other examples are seL4 (a proven correct micro kernel used on millions of devices), CompCert (a proven correct C compiler used by Airbus), TLA+ used by AWS etc. There are many more examples. So yes it is not main stream but it is being used where it counts.
deleted 2mo ago
[deleted]

128 points by Thom2503 2mo ago

Where formality, when right, still goes wrong: 0) premature but fitting; 1) settled but situationally mismatched; 2) same formal token, different external meaning.

s_dev 2mo ago

https://blog.janestreet.com/formal-methods-at-jane-street-index/ https://blog.janestreet.com/formal-methods-at-jane-street-in... I thought this article from Jane Street makes a nice complimentary pairing.

exogenousdata 2mo ago
And it’s not just blogs. They’ve got an open job posting [0] for a ‘Formal Methods Engineer’. [0] - https://www.janestreet.com/join-jane-street/position/8585303002/ https://www.janestreet.com/join-jane-street/position/8585303...
rstuart4133 2mo ago
And this pairs nicely with Jane Street's observation that agentic coding changes the formal proof equation: https://news.ycombinator.com/item?id=49064854 https://news.ycombinator.com/item?id=49064854 Formal proofs of code are almost beyond the capabilities of the best human programmers (3.7 lines per day!), but LLMs can bash out code at an amazing pace. It's often crap, sadly, but the proof they are bashing out is the hard bit. If possible at all, the task is EXPTIME. Verifying the proof is only P, so when it's wrong you tell the LLM to do it again. A stable agentic loop is what makes it possible. The results in the article I linked to speak for themselves.

SCdF 2mo ago

In most industries that need software made for them it's hard enough to get people to care about spending enough time on informal methods let alone formal ones. I simply don't think most of the industry has had the breathing room and respect for engineering for this pattern to develop.

another_twist 2mo ago
I think its also about tolerance for failure. For software that must not fail or where reliability commands a premium you would be wise to invest in formal methods. Core systems at aws for example. For throwaway CRUD code its just easier to try iterations on the problem and call it a day. Its not about respect just RoI.
forinti 2mo ago
I think programmers in general do not give much thought to the level of engineering required for a task. Mostly, there's too little, but there are many cases when there's too much. I see people writing tons of tests for corporate software that will be used by a couple of people and will have to be updated regularly anyway. Building a hut is not the same as building a skyscraper, but we don't really have guidelines for different software projects. No methodology I've ever seen distinguishes types of projects by complexity.
- epolanski 2mo ago
  I know few 100% unit test coverage, strictest typing to encode invariants fellas who's app is consistently broken and product makes less money than the bakery in my village.

unprovable 2mo ago

This blog is actually very useful... There's also the flip side, possibly due to the expense (technically, intellectually, and emotionally), where "IT'S FORMALLY VERIFIED!!" has become some marketing code for "it's safe, secure, and PFAS free..." - just because something is formally verified, doesn't mean it's secure or fit for purpose. It usually just means it conforms to a given spec "and that's that..."

asxndu 2mo ago

I think it's the culture is software engineering. In a food delivery app/social network it seems like a waste of time to use formal methods. When designing software for aircraft, pacemakers, fintechs, cryptography and DeFi protocols there is a bit of value for formal methods. The problem is that often, people with the food app/social network culture are hired to build DeFi protocols. Which explains why so much money is being stolen form DeFi protocols of late. So why people don't use formal methods. - 95% of the time, the stakes are low - 5% of the time, the engineers don't understand the value of formal methods. Leslie Lamport once joked that if software developers were architects, they would first build a skyscraper and then later draw the blueprint.

antonvs 2mo ago
I enjoyed this quote from the article, which concisely summarizes the first part of the above comment: > “website isn’t airplane!!!”
kalcode 2mo ago
Also you can write a perfect specification get into implementation and have to step back and redesign. Software is fast to iterate and test that a lot assumptions can be proven by actually writing the code. Software is closer to gardening or painting. We discover a lot through practice and writing code. Then we can often write more formal specifications. But formal method is impractical for most software upfront, and instead is likely used for more serious runtime failures or cost of life. That's just my two cents.

vslira 2mo ago

Speaking for myself (and I bought Hillel's recently published Logic for Programmers): It's not clear to me which formal method I should use. I'm certain the answer is "there's a different best one for each situation", but I don't want to know one for each problem I'll face. I'd rather have a definitive answer to what is the second best for all situations, similar to how we can answer "python" to that question when the question is about general programming

antonvs 2mo ago
> similar to how we can answer "python" to that question when the question is about general programming An ironic claim in the context of formal methods.
- dahart 2mo ago
  Out of curiosity, why’s that? I don’t know formal methods nor the relationship to python.
  - mrkeen 2mo ago
    The most widely available, useful, and best-bang-for-buck formal method is using a good type system.

ndriscoll 2mo ago

We do. It's called a type checker. Every "formally verified" system is going to be partially verified. e.g. you might prove your sort procedure sorts, but did you prove its complexity? Under a cost model for integer compares or a cost model for page fetches? Or both? Multi-layer cache page fetch costs? How well you verify just depends on how well you decide to model the problem. Different type checkers have different modeling features. This is a more useful perspective; it's not "we do/don't use formal methods," but instead "how can I more precisely model my domain?" Helpfully, if you model your domain well, code tends to be obvious/write itself.

yoshuaw 2mo ago
One of my favorite quotes on this topic is: "Type systems are just the parts of formal verification we've figured out how to make fast."
- honr 2mo ago
  Thankfully this is no longer strictly true. So, I think the quote needs a slight adjustment, "Type systems and $THING are just ...", but $THING is not very well defined yet. Between "linters", and other relatively fast AST-based rule enforcers, some of which looking at higher order behavior, I think we now have an amalgamation of formally verified concepts that we can consider fast enough and sufficient exercised in practice that we are ever closer to widespread formally and dependably verified software. Still, it's a long journey, and academic formal verification would always be, by design, a few steps ahead of what the industry can do efficiently in practice.
  - Taikonerd 2mo ago
    The field really needs more popularizers. I mean people or projects who can do "advertising" like, "if you add our linter to your CI/CD pipeline, you'll never have X class of bug ever again!"
- rrook 2mo ago
  given your experience on the topic, i'm curious: do you think that the reason we haven't figured out how to make other parts of formal verification fast is that, in general, programming languages expose each individual machine operation in the code, so the verification surface area is the combinatorial set over that? i've been working on a low level high opinion language, and its verifications are able to be checked in an extremely tight loop, largely because of the structure of the language itself.

IshKebab 2mo ago

I think everyone knows the answer already - it's too hard to be worth it for most problems. The article doesn't disagree with that and was a good read anyway. Don't skip it because you already know the answer. IMO the reason is way more on the "it's too hard" side than "it isn't worth the effort". Formal verification is extremely common in the silicon hardware design world, despite its extreme cost (the tool licenses cost on the order of $100k per seat, as far as I can tell). And in this domain bugs are really expensive. But I think it would be used in spite of that simply because it is an order of magnitude easier than software formal verification. I don't know if there is any solution to that. Software itself is an order of magnitude (or more) more complex than hardware... I think the author's suggestion of partial verification is the way to you. You're not going to formally verify your GUI but you could formally verify your LZ4 decoder. Maybe.

win311fwg 2mo ago
Formal verification is also extremely common in the software design world, to be fair. Most programming languages in use have at least a primitive type system and even those that historically didn't are gaining them (e.g. Typescript, Python gradual typing, etc.) The question is, as always, to what degree do the returns start to diminish. The Rust crowd laughs at Go's level of formal verification and says that their level of formal verification is the right level, but then the Lean crowd laughs at Rust's level of verification and says that their level of formal verification is the right level. The universe laughs at all of them. For crowds so concerned about mathematical proofs, it is funny that they end up right back at gut feeling.
- IshKebab 2mo ago
  It's a continuum... but I would say even Rust's type system is not in the realms of "formal verification". I think you need at least some kind of refinement types so you can say "an integer between 1 and 10" before you can stake even a vague claim to "formal verification". So I don't think you can say it's common in the software world.
  - win311fwg 2mo ago

malisper 2mo ago

I recently came across a use case where formal methods were incredibly helpful. I've been rewriting Postgres in Rust and am currently focusing on correctness. The biggest challenge is that there's so much surface area to cover. Postgres has over 3000 user-facing functions, ranging from regular expression matching to JSON iteration to computing the gamma function. About half of these functions are simple pure functions. Of the 3000 functions, I've been able to formally verify that the Rust behavior is identical to the Postgres C behavior for over 1000 of them. In the process, I found 4 different Postgres bugs. All of them would not be triggered under ordinary usage, but one, if triggered, would corrupt your database. I think why formal methods works well for this is I'm testing a large number of small to medium self-contained pieces of code. For each of them the specification is simple: does postgres_fn(args) == pgrust_fn(args). I've been using Kani[0] which works across both Rust and C code so the proofs are based off the actual code and not a translation of the code to another language. If you want to check out what all the verification look like, you can see them here[1] [0] https://github.com/model-checking/kani https://github.com/model-checking/kani [1] https://github.com/malisper/pgrust/tree/main/proofs https://github.com/malisper/pgrust/tree/main/proofs

excitedrustle 2mo ago
> I found 4 different Postgres bugs. Bugs in the upstream Postgres C implementations? Did you report them or submit patches? I'm curious to see what you found!
- malisper 2mo ago
  Yep, I did submit bug reports. This was on Tuesday. I don't see a public copy of the mailing list that has my bug reports yet. The four bugs were: 0) When parsing a macaddr[0], Postgres uses sscanf with %x. %x can wraparound. This means SELECT '10000000aa:bb:cc:dd:ee:ff'::macaddr; will return aa:bb:cc:dd:ee:ff. 1) When parsing a tid[1], Postgres uses strtoul. The return value of strtoul is different across platform for the empty string. This means on some platforms Postgres SELECT '(,5)'::tid; will error and others will accept it. 2) Postgres missed an overflow check in it's cash type[2]. When running SELECT '-92233720368547758.08'::money / (-1)::int8; some platforms will error and other's will return the MIN value. Postgres does check for this for some of the other cash related functions, but it missed it for one of them. 3) When hashing the "char" type Postgres will cast a char to an integer[3]. On some platforms char is signed and on others it's unsigned. This means the hash of a char can be different depending on the platform. If you are using a hash index or hash partitioning on a char and move your DB from x86 to arm, the hashes will differ and your index/partitioned tables become corrupted. Note that this is special char type that you have to refer to by "char" that is separate from the typically used CHAR(n) type which is what you typically use, hence this would never come up under real usage. The common pattern with all of these is they rely on C behavior that differs across platform (integer overflow, char signedness, strtoul). Rust is better about having more consistent behavior across platforms so these cases get flagged when the Rust code and the C code differ. [0] https://github.com/postgres/postgres/blob/REL_18_3/src/backend/utils/adt/mac.c#L71-L81 https://github.com/postgres/postgres/blob/REL_18_3/src/backe... [1] https://github.com/postgres/postgres/blob/REL_18_3/src/backend/utils/adt/tid.c#L75-L81 https://github.com/postgres/postgres/blob/REL_18_3/src/backe... [2] https://github.com/postgres/postgres/blob/REL_18_3/src/backend/utils/adt/cash.c#L155-L165 https://github.com/postgres/postgres/blob/REL_18_3/src/backe... [3] https://github.com/postgres/postgres/blob/REL_18_3/src/backend/access/hash/hashfunc.c#L47-L51 https://github.com/postgres/postgres/blob/REL_18_3/src/backe...

dirkc 2mo ago

Isn't the problem with formal methods that it isn't clear whether or not most of the useful code we use are actually formally verifiable? The article mentions NP-complete, but is it actually a solvable problem in general? > For extremely restricted cases, like propositional logic or HM type-checking, it’s “only” NP-complete.

angry_octet 2mo ago
No, lots of problems can be expressed in a way that can be verified. But complete verification of an existing implementation is essentially impossible. That doesn't mean that formal techniques are not useful, far from it. For example, AWS uses a formally specified model to verify if an implementation is correct by looking at the telemetry. See e.g. https://p-org.github.io/P/advanced/pobserve/pobserve/ https://p-org.github.io/P/advanced/pobserve/pobserve/ This isn't something you could meaningfully do with standard testing techniques, and it very compositional, you can do it piece by piece.

the__alchemist 2mo ago

My 2c I don't understand any of the material I've read describing them. What I do understand makes them sound like it will be a load of work for questionable benefits. If I end up writing safety-critical code. (Aerospace firmware, big robots etc), I will get over this hump and learn them. If not, I am not yet compelled; rather intimidated. Maybe this is like Quaternions, that are actually very easy and useful, but suffer from confusing descriptions. Or maybe more like Monads, which are actually very abstract, and may not be suitable unless your the sort who understands Mathematician style mathematics. More to the point: I'm not even sure how I would get started and evaluate them tacitly. Of particular confusion: Does formal verification lead to a strange-loop style or "It's verification all the way down" scenario, where you are shifting the correctness from the original code to the verification? Then must verify the verification ad-infinitum? (This is almost certainly wrong, but I don't grasp why) The big question I ask: "Would I rather have a code base with formal verification, or one in which all the time and effort used by add that were spent using and testing the software in a practical way; or code reviewing it"

Taikonerd 2mo ago
> Does formal verification lead to a strange-loop style or "It's verification all the way down" scenario, where you are shifting the correctness from the original code to the verification? Then must verify the verification ad-infinitum? IANA formal methods guy, but my understanding is: yes, you're shifting the correctness burden from the code to the spec. So why is that better? Because the spec is much shorter and more focused -- it strips out all of the implementation details. It's bad to say "you have to trust this 100,000 line program." It's much better to say "you have to trust this 100 line spec, and the code that verifies it."
- the__alchemist 2mo ago
  That is a great explanation!

StilesCrisis 2mo ago

Because there is almost never a business need? Most programs don't need to be rigorously perfect. If they did, LLMs wouldn't be as popular as they are right now. If you're dealing with medical equipment or space flight, maybe there's a need. But usually the goal is to make errors _inexpensive_ to find and fix, not theoretically impossible.

eru 2mo ago
The ironic thing is that LLMs are what will make formal methods feasible. First: LLMs find so many bugs and security holes in software right now. So you pretty much have to prove your stuff correct, if you don't want to get hacked into. Second: LLMs make it much easier to apply formal methods. Just ask Claude to prove your stuff in Lean or whatever, no PhD required anymore.
akshayshah 2mo ago
I'm not sure how to think about what you mean by "almost never." If most commercial software is web frontend + monolithic app code + relational DB, then you may very well be right. That doesn't quite match my professional experience, though - there are so many companies building databases, message queues, filesystems, and similar infrastructure. Sometimes they're internal projects, and sometimes they're commercial products. I've always felt that those systems would benefit from formal methods, since they're usually trying to provide strong guarantees to the application code on top.
- StilesCrisis 2mo ago
  Almost all software is internal "make the business run" software that we never see, or web pages. Very very few engineers would even consider making a new message queue. The crowd here is different than most :)

teiferer 2mo ago

To me, "this returns sorted lists" illustrates the crux. You may know exactly what you want, and you may have a reasonably fast and cheap way to verify your code against a formal specification. But the formal specification needs to come from somewhere and for any non-trivial program its complexity is going to be in the same order of magnitude as the code implementing it. So we are back to writing "code" (which is what a formal specification is) that needs to be checked against what we actually want. And that "code" needs .. a test? Hard thinking? A formal verification itself? Don't believe me that this is hard? Back to "this returns sorted lists". The promise of formal verification is that whatever implementation I throw at the verifier, as long as it passes the check, I'm happy (assuming that I can also encode things like running time and resource use). Now imagine a program that always returns the empty list. It satisfies "this returns sorted lists" trivially but is not at all what we want. The formal spec has a bug. Such issues can be subtle in larger projects and no amount of model checking or SMT solvers can guard you against a bug in that "code". Don't get me wrong, it can be incredibly useful. But it's not the silver bullet that some proponents make it out to be. It's another tool next to testing, not instead of it. (The whole "testing can only prove the existence of bugs, not their absence, that's why we should use formal verification instead" is just misguided at best and propaganda at worst.)

bluGill 2mo ago
I have a deeper problem. When I'm calling sort() it is useful that it returns a sorted list. However my program rarely has sorted lists of any sort in any requirement. My requirements are around the features my users care about. Sure the list of employees that I need to display needs to be sorted (sometimes by hire date, sometimes by title, sometimes by name - and often combinations of the above), but there are a lot of things I'm doing with that list that are not sorting.
- teiferer 2mo ago
  In which way is that a "deeper" problem? What you are doing with that data can also be expressed as a formal spec. Sorting is just used as an example everywhere because everybody knows exactly what we are talking about without having to explain a lot, it has a somewhat easy solution space and everybody has implemented some form at some point, likely in school, for the same reasons . Of course real world software is more complex that that but that's not the point.

tombert 2mo ago

I've been a big nerd for formal methods for quite awhile, and have been broadly unsuccessful in getting employers onboard. I have pretty cynical opinions as to the "why" of this, largely involving the fact that the vast majority of software engineers refuse to learn anything that they weren't explicitly taught in college, but regardless of the reason whenever I have tried proposing TLA+ in the past, people will nod along and wait for me to stop talking. I've had several managers say "they'll look into it", which was such an obvious lie that I don't know why they even bothered. I've "snuck in" TLA+ usage a few times. I gave up on getting anyone else to use TLA+, but as I've gotten more senior-level, I have been given a fair bit more leeway on how I approach projects and as such I have been able to budget myself a day or two to model some of the less-obvious bits of concurrency. All that said, I have had some luck with designing stuff with TLA+, then feeding the spec into Claude and getting that to implement the actual executable code. Maybe I'll be able to convince an employer that's a good use of time now.

plastic-enjoyer 2mo ago
> I have pretty cynical opinions as to the "why" of this, largely involving the fact that the vast majority of software engineers refuse to learn anything that they weren't explicitly taught in college, but regardless of the reason I think it's not only SWEs, but general persons that goe to college primarily to get a job, without having a natural curiosity for things.
- tombert 2mo ago
  Probably true, I've just only ever worked in the software engineering world so I cannot speak about anything else.
epolanski 2mo ago
Software engineers are rarely engineers at all, and pretty much never know anything about computer science.
- tombert 2mo ago

joelthelion 2mo ago

I would say the tooling plays a part. Where are the go-to open source solution that a beginner can turn to without too much research?

poly2it 2mo ago

For me, I wish the systems languages I am interested in could couple with legible verification systems, but alas, the world of formal methods seems disjoint. The only way to get a satisfactory development experience seems to be to learn Lean.

Jtsummers 2mo ago
> The only way to get a satisfactory development experience seems to be to learn Lean. Or SPARK, if you want to stick to systems languages.

dcminter 2mo ago

Pretty much every job I've had has involved integrating with highly imperfect, changeable, and inaccurately implemented (and barely documented) third party APIs. That's where most of the work went and I don't see formal methods improving the situation any time soon.

appplication 2mo ago

(Edit: replied to wrong comment)

deleted 2mo ago

[deleted]

taybin 2mo ago

I would love to see an example of a proof for something like a text editor. How can people be expected to do this when the examples are always trivial toys, like array sorting? Show me a formal proof of something that in the trenches programmers can copy from. A proof of a basic todo list or something like that.

bluGill 2mo ago
That is always my problem too. I can see how to prove sort, if I was writing the standard library for my language I might do that (it is hard, but I hope whoever wrote my library did). However sort is already in my library. I'm writing code that does things much harder to write into a spec.
warkdarrior 2mo ago
My guess is that the formal spec for a basic TODO list app is the same size as the source code of the app itself.
- antonvs 2mo ago
  I would not be even slightly surprised if it were larger.
mrkeen 2mo ago
> A proof of a basic todo list or something like that. Just using a verb here would be a first step toward rigorous thinking. A proof that a todo list does what?
- taybin 2mo ago
  To-does. Just like how a butler buttles.
  - antonvs 2mo ago
    Excuuuuuse me, I believe that should be to-dos.

kansface 2mo ago

Has anyone been experimenting with AI and formal methods - verification, proofs, or anything else? I've been thinking about this space quite a bit lately. For sufficiently interesting AI generated software, AI is also incapable of reviewing it - possibly for the same reason that humans are. AI ought to be able to adopt the formal methods humans have used to work around the inability to verify something just by looking at it hard. If the cost of adoption is what stopped us, thats no longer an issue.

SebTardif 2mo ago
[flagged]

1970-01-01 2mo ago

When I interviewed at AWS, I asked this question directly to their formal methods expert. Her response was two-fold: 1. All our code changes too much, we wouldn't be able to formalize it before it needed to change. 2. We already did this where we could, you just don't see it. I didn't get the job and remain very skeptical on both answers. I think they just didn't have enough power internally to change the move fast and break everything culture for the better.

antonvs 2mo ago
Why are you skeptical on point 1? For anything more complex than standard static type checking[], they're almost certainly correct. [] or, say, Haskell-level type checking. Which admittedly, AWS is not doing.

fauigerzigerk 2mo ago

"Much of this is a consequence of designs are not code. With most design languages, there is no automatic way to generate code" Maybe now there is, but I don't know how good LLMs are at using these relatively obscure (at least to me) design languages.

Merkur 2mo ago

Interesting read, thank you. I share your goal, and I think with AI- coding proving code right has become more relevant than ever. What prevents that we, just move the goal post? Moving the bug from code to spec? The spec must always be simpler and more easily to understand and debug than the code. But in praxis that means it can’t be fully specific in most of the use cases?

wduquette 2mo ago

I was exposed to Z notation in the late 80's, and could not for the life of me see how to apply to my work as a junior programmer. But the distinction the OP makes between Design and Code Specification was lost on me then (and, I think, on the folks I knew who were looking at Z); and the OP indicates that Z is aimed at Design Specification. As a junior programmer, it's no wonder it was lost on me.

scrubs 2mo ago

A little self promotion: for a way to see how to use TLA as a formal method see: https://news.ycombinator.com/item?id=48287718 https://news.ycombinator.com/item?id=48287718 I give a comprehensive introduction to formal methods without assuming background with a constant emphasis on examples, and using the tool.

deterministic 2mo ago

People do use formal methods. Type checking is a simple form of formal methods. Some languages have type systems that are advanced enough to prove code correct (LEAN/Agda/...) Other examples are seL4 (a proven correct micro kernel used on millions of devices), CompCert (a proven correct C compiler used by Airbus), TLA+ used by AWS etc. There are many more examples. So yes it is not main stream but it is being used where it counts.

deleted 2mo ago

[deleted]