dafny

ion, GPUs, TPUs/NPUs, Hypervisors, OS schedulers, IPC,] Still though, coverage-based fuzzing; From https://news.ycombinator.com/item?id=30786239 : > OSS-Fuzz runs CloudFuzz[Lite?] for many open source repos and feeds OSV OpenSSF Vulnerability Format: https://github.com/google/osv#current-data-sources From "Automated Unit Test Improvement using Large Language Models at Meta" https://news.ycombinator.com/item?id=39416628 : > "Fuzz target generation using LLMs" (2023), OSSF//fuzz-introspector* > gh topic: https://github.com/topics/coverage-guided-fuzzing The Fuzzing computational task is similar to the Genetic Algorithm computational task, in that both explore combinatorial Hilbert spaces of potentially infinite degree and thus there is need for parallelism and thus there is need for partitioning for distributed computation. (But there is no computational oracle to predict that any particular sequence of combinations of inputs under test will deterministically halt on any of the distributed workers, so second-order methods like gradient descent help to skip over apparently desolate territory when the error hasn't changed in awhile) The Fuzzing computational task: partition the set of all combinations of inputs for distributed execution with execute-once or consensus to resolve redundant results. DbC Design-By-Contract patterns include Preconditions and Postconditions (which include tests of Invariance) We test Preconditions to exclude Inputs that do not meet the specified Ranges, and we verify the Ranges of Outputs in Postconditions. We test Invariance to verify that there haven't been side-effects in other scopes; that variables and their attributes haven't changed after the function - the Command - returns. DbC: https://en.wikipedia.org/wiki/Design_by_contract : > Design by contract has its roots in work on formal verification, formal specification and Hoare logic. TLA+ > Language: https://en.wikipedia.org/wiki/TLA%2B#Language Formal verification: https://en.wikipedia.org/wiki/Formal_verification From https://news.ycombinator.com/item?id=38138319 : > Property testing: https://en.wikipedia.org/wiki/Property_testing > awesome-python-testing#property-based-testing: https://github.com/cleder/awesome-python-testing#property-ba... > Fuzzing: https://en.wikipedia.org/wiki/Fuzzing Software testing > Categorization > [..., Property testing, Metamorphic testing] https://en.wikipedia.org/wiki/Software_testing#Categorizatio... -- From https://news.ycombinator.com/item?id=28494885#28513982 : > https://github.com/dafny-lang/dafny #read-more > Dafny Cheat Sheet: https://docs.google.com/document/d/1kz5_yqzhrEyXII96eCF1YoHZ... > Looks like there's a Haskell-to-Dafny converter. haskell2dafny: https://gitlab.doc.ic.ac.uk/dcw/haskell-subset-to-dafny-tran... -- Controlled randomness: tests of randomness, random uniform not random norm, rngd, tests of randomness: From https://news.ycombinator.com/item?id=40630177 : > google/paranoid_crypto.lib.randomness_tests: https://github.com/google/paranoid_crypto/tree/main/paranoid... docs: https://github.com/google/paranoid_crypto/blob/main/docs/ran...

m/microsoft/CodeContracts [4] https://github.com/dafny-lang/dafny [5] https://github.com/dotnet/csharplang/issues/105

reference CompCert C will fail to generate the example UB code. But yes, mechanically proving additional properties with some kind of SAT solver is also an open area of research. Dafny is the example I’m familiar with. Its conditions and invariants allow things like automatically proved binary search[2]. Converting CompCert C statements to SMTLibv2 assertions (which is, to an extremely rough first approximation what Dafny does) would certainly be considerably easier than it would be for most other languages. It would still be a serious effort of course. [1] https://blog.regehr.org/archives/232 [2] https://github.com/dafny-lang/dafny/blob/master/Test/dafny4/...

e and practical. Actually, Facebook (Meta now) argues Infer let's them move faster. I think the problem is political and economical. It's hard to monetize this first. I wish someone like Apple took the plunge and rebuilt a simpler version of their stack using formal verification. It's the kind of thing only a large corporation or a government can do because it might take half a decade to take off. Once it takes off its unstoppable. Who would not like to buy e.g. a phone where most bugs and security breaches are impossible by construction? Verification also has a nice side effect. Change for the sake of change and featuritis are pretty incompatible with it. [1] https://fbinfer.com [2] https://github.com/dafny-lang/dafny

le properties. An elementary example of this are truss structures in mechanical engineering. There is not that much research direction in this area. Personally, I like Dafny [2]. There is quite a lot of research on advanced type systems and theorem proving, but I think there is still a big gap in usability and automation. I think DSLs to restrict semantics + automated program analyses could be an excellent alternative. Infer [3] is pretty nice. Similar approaches that targeted a language with better semantics would be able to offer a lot more guarantees. [1] http://objective.st/About [2] https://github.com/dafny-lang/dafny [3] https://fbinfer.com

com/products/ecv.php [6] https://trust-in-soft.com/