Where can you find me?
BlueSky: https://t.co/LNDR5DtB6Y
YouTube: Craft vs Cruft https://t.co/akthyWudWe
Podcast: https://t.co/PPaOXe3NOQ
LinkedIn: https://t.co/Ljk5Ch0l4e
Tomorrow is AI Native DevCon, where our chief architect @lambdapocalypse will be giving a talk on "The Many Ends of Programming"!
We're proud to partner with them for this exciting and timely event, register here: https://t.co/q2iAkOBkME
@JoshuaG19367959@petereliaskraft Fair question, it's a hybrid technique. Looks like it's differential testing against a formally verified reference implementation, so I think the difference would be the verification of that spec.
They used a similar technique with Cedar.
https://t.co/Skt8vpRodz
What if you could prove your program is correct? Not just "looks good to me", but a formal mathematical guarantee that it does what you want?
This formal verification is far too difficult for most programs we write, but for the most critical software in the world, it may be worth it. There's not much software more critical than AWS S3, which is why this paper on how they formally verify part of its internals is so interesting.
This paper focuses on one of the lowest-level, most complex, and most critical parts of S3-the storage node servers that persist object data on hard disks. When this paper was written, AWS was in the process of migrating to a new, higher-performance storage server implementation written in Rust, called ShardStore. Before moving critical customer data to ShardStore, they set out to formally prove its correctness.
The main goal of the verification effort is to prove the storage servers don't lose or corrupt data: they're durable in the absence of crashes and consistent in the presence of crashes or concurrency.
The AWS team implemented verification in two main steps. First, they built reference models of their system that define its expected semantics. These are small executable specifications (1% of the size of the original) that are embedded in the code base and continuously updated alongside it.
Then, they verify that the actual system has equivalent observable behaviors to the reference model. Generally, the way they did this was through highly sophisticated fuzzing, running tens of millions of automated tests on the real system with cleverly chosen inputs and quickly validating that the observable semantics of the real system were equivalent to that of the reference model. This is far more effective than regular fuzzing because the reference models allow rapidly checking if all the system's observable behaviors are correct.
This kind of verification work isn't easy to do (and it depends on correct reference models) and isn't suited for every application. But if half the world's infrastructure depends on what you're building, then it's good to have stronger guarantees your code is correct!
@_diginova@wordgrammer I like your intuition of dividing up the problem and specializing models, that seems right. I’m interested in a wider variety of components then just ML models though, for instance theorem provers which could be thought of as Symbolic AI.
@_diginova@wordgrammer Personally I don’t see why LLMs would be a better way to synthesize Asm vs more traditional techniques involving tree-transformations or program search
@waldenpod 2. Systems Thinking is counterintuitive, and easy to misunderstand for people not acclimated to it.
So when Dennett reaches across abstraction levels to make a point, you need an appreciation that a statement about the parts is NOT claiming the nature of the whole.
@waldenpod Hmmm. Couple thoughts:
1. People with the idea that atheists value nothing, hate humanity etc seem to try to read that into anything said.
E.g “They said space was vast - see I knew they thought life was meaningless”
@alexbunardzic A standard line goes something like: a team is a working group that collaborates on a common goal.
It’s probably fuzzier than that but words like “cohesion”, “shared understanding”, “reciprocity” come to mind.
@welltypedwitch I eventually assumed Strong was more of a value judgement but before that I thought Common Lisp was a good example of Strong + Dynamic.
So I’m curious to see if that was true based on more grounded definitions
@techsavvytravvy It was a survey class so a variety of different theories of morality were presented - we did try at one point to get him to tell us which one he thought was best but he didn’t budge :)