Programming

18333 readers

516 users here now

Welcome to the main community in programming.dev! Feel free to post anything relating to programming here!

Cross posting is strongly encouraged in the instance. If you feel your post or another person's post makes sense in another community cross post into it.

Hope you enjoy the instance!

Rules

Follow the programming.dev instance rules
Keep content related to programming in some way
If you're posting long videos try to add in some form of tldr for those who don't want to watch videos

Wormhole

Follow the wormhole through a path of communities !webdev@programming.dev

founded 2 years ago

MODERATORS

snowe@programming.dev

Ategon@programming.dev

MaungaHikoi@lemmy.nz

What are some good resources to learn to write very reliable/formally verifiable software? (lemmy.world)

submitted 5 days ago* (last edited 5 days ago) by flavonol@lemmy.world to c/programming@programming.dev

17 comments fedilink hide all child comments

The University of Pennsylvania offers a free series of books called Software Foundations with the following description:

The Software Foundations series is a broad introduction to the mathematical underpinnings of reliable software.

The principal novelty of the series is that every detail is one hundred percent formalized and machine-checked: the entire text of each volume, including the exercises, is literally a "proof script" for the Coq proof assistant.

The series includes Verifiable C, which seems very appealing as a way to avoid some of C's infamous "footguns." I haven't read the series myself, but I might in the future because I like math, logic & programs that do what they're supposed to do.

Are there any materials that would be good as alternatives or complements to this series?

Edit: Adding the Vercors Wiki to the resources in this thread

you are viewing a single comment's thread
view the rest of the comments

[–] kata1yst@sh.itjust.works 23 points 5 days ago* (last edited 5 days ago) (2 children)

The NASA secure coding standards are overbearing, obnoxious, over-engineered, and a huge waste of effort.

But they are absolutely correct and the best guidelines I'm aware of.

https://standards.nasa.gov/standard/NASA/NASA-HDBK-2203

https://standards.nasa.gov/standard/NASA/NASA-STD-871913

https://dev.to/xowap/10-rules-to-code-like-nasa-applied-to-interpreted-languages-40dd

[–] flavonol@lemmy.world 5 points 5 days ago (2 children)

The Software Engineering Handbook PDF appears to just be a single page with a broken link on it; is there an archive for the document that's supposed to be there?

[–] Hammerheart@programming.dev 8 points 4 days ago

That's kindeof poetic tbh

[–] kata1yst@sh.itjust.works 2 points 5 days ago (1 children)

Sorry about that, I'm seeing the same. Here's the site linked from the Internet Archive

https://web.archive.org/web/20240328153801/https://swehb.nasa.gov/

[–] Comment105@lemm.ee 5 points 4 days ago (1 children)

Would this be a consequence of the Project 2025 federal purge?

[–] PokerChips@programming.dev 1 points 4 days ago

I was just checking the archives and all captures seem to work that I checked until now. Wondering if they're moving it to WordPress. /s

[–] tatterdemalion@programming.dev 0 points 5 days ago* (last edited 5 days ago) (1 children)

I definitely cannot get behind the "no recursion" rule. There are plenty of algorithms where the iterative equivalent is significantly harder and less natural. For example, post-order DFS.

I guess maybe when lives depend on it. But they should be testing and fuzzing their code anyway, right?

EDIT: I can't even find in the NASA PDF where it mentions recursion.

[–] FizzyOrange@programming.dev 12 points 5 days ago

You can transform any recursive algorithm into iterative pretty easily though; just create a manual stack.

The rule definitely makes sense in the context of C code running in space. Unbounded recursion always risks stack overflow, and they probably don't have any tooling to prove stack depth bounds (you totally can do that, but presumably these standards were written in the 1500s).