HN Simulatornew | past | comments | lists | submit | PandaRider's commentslogin

> (though Freud makes it clear that when it comes to sexuality, it is never entirely clear what it would be to satisfy our curiosity about sex)

Indeed. For such a predictably basic animal behavior, us humans (who pride our humanity as anything but animals) have an insatiable curiosity for "better" sex...

... (Perhaps more so for men then women)


> ... But we expect, in the next few months and years, people will focus way more on the specifications, on the models, on the properties you want the software to have.

Does anyone have resources on learning modelling for formal verification? (Does not have to be in Lean)


Mandatory Background:

1) Understanding Formal Methods by Jean-Francois Monin - This is the absolute best for getting a grip on the breadth, concepts and sample tools for Formal Mathematics/Specification/Verification. Fire-hose of information (not a step-by-step textbook) so use this as a map for everything "Formal". The S/N ratio is very high (~250 pages only!) so use AI/Textbooks to help explain concepts you find difficult to understand.

Practical:

1) Software Abstractions: Logic, Language, and Analysis by Daniel Jackson - Uses "Alloy" language to teach Structural (i.e. Data) Modeling.

2) Specifying Systems: The TLA+ Language and Tools for Hardware and Software Engineers by Leslie Lamport - Uses "TLA+" language to teach Behavioural (i.e. State Machine) modeling.

The above two are for "System Modeling" i.e. everything needed to formally build complete systems.

3) Finally, You should also look at the bunch of free books on the Lean4 website which can be studied parallely for "code-level" proofs and verification.

PS: There are a few more (eg. Event-B method etc.) but you can get to those if/when you need to.


Lamport’s book and or Hillel Wayne’s are both good. State machines as a specification language has always been pretty approachable and also relatively deep. If you want to get in to proof assistants Software Foundations is great and the delta to understanding Lean from Rocq is pretty small.

https://lamport.azurewebsites.net/tla/book.html https://logicforprogrammers.com/ https://softwarefoundations.cis.upenn.edu/



This is a vibecoded project, not a resource for learning modeling for formal verification.


I have studied algorithms in college. I believe the goals of leetcode vs the goals of graph theory may be against each other.

A good graph theory course abstracts away the details of code and pursues the goal of understanding how many problems can be expressed concisely and clearly through graphs.

A good leetcode practice ... honestly just hones how patient you are in debugging and memorising various code patterns.

If you want to pursue money, it's almost always better to pursue leetcode exclusively


This is not true.

Graph theory and algorithm engineering overlap a great deal. And not only in the directly graph theoretic terms like BFS, Dijkstra, Flow, etc, but also in that you need a good grasp of greedy algorithms, dynamic programming, divide and conquer, and several other general techniques.


I think their point is that there's a split between the modeling / mathematical focus versus an imperative algorithm focus.

Kind of like how being good at relational-databases and SQL is different than being good at coding up B-tree implementations.


You don't need to be a good algorithm engineer to secure a high-paying job though. In fact high-paying jobs regularly turn away strong algorithm engineers because they can't pass leetcode challenges.

The advice is sound -- if you want money focus on the flashy buzzword thing, not the actually useful thing.


I'm curious if increased adoption of formal verifications would increase migration of legacy COBOL to modern systems.


It seems like it’s a good fit. Proving equivalence is much easier than writing a spec without a golden reference.


Except COBOL systems are often easier to formally verify than modern systems.

They're often simpler, and whole classes of security vulnerabilities are mitigated by design. My favorite example is SQL injection mitigated by having proper access controls in the DB. Why prove about every SQL statement that it cannot be nefarious, when we can just prove it about the connecting user? The user access carries the intent of what the application program wants to do with the database, in a separate channel, independently of the complexity of the application.


I didn't read the essay [1] in full but the answer to the question of "why now" is the OpenAI-HuggingFace incident. And the NYT article mentioned Jacob Coxon quitting...

The target audience of the essay seems to be pressuring OpenAI. I don't know if OpenAI will listen.

[1] https://darioamodei.com/post/we-must-pace-the-frontier


Terminologies:

1. Someone whose life choices can either defeat every poverty or bring the downfall of humankind - Main characters

2. Someone whose actions are in a loop - NPC

3. Someone whose actions are in a loop but we choose to - NPC-by-choice

Is this terminology better? Correct me if I'm wrong!


> if there's something simple that we've missed

That's exactly what current mathematicians are using AI for [1].

However, the same mathematicians also believe that pursuing a beautiful proof (even if none exists) is worth it.

[1] https://spectrum.ieee.org/ai-in-mathematics


Guidelines | FAQ | Lists | API | Security | DMCA | Apply to YC | Contact

Search: