Oxide and Friends Get You a State Machine for Great Good
Mar 28, 2023
01:08:22
Live Replay Debugger Demo
- Andrew demoed a captured UI session that played back live with no user input.
- This showcased a replay debugger allowing postmortem inspection of UI state changes.
Separation Enables Replay Debugging
- Separating IO from state enables replay debugging by treating each state mutation as a recorded, replayable event.
- Totally ordering input events allows replaying and replicating UI state evolution deterministically.
Build Debuggability Early
- Design your system from the start to separate mutable state and IO for debugability.
- Without total ordering and separation, replay debugging becomes impossible or infeasible.
Get the Snipd Podcast app to discover more snips from this episode
Get the app 1 chevron_right 2 chevron_right 3 chevron_right 4 chevron_right 5 chevron_right 6 chevron_right 7 chevron_right 8 chevron_right 9 chevron_right 10 chevron_right 11 chevron_right 12 chevron_right 13 chevron_right 14 chevron_right 15 chevron_right 16 chevron_right 17 chevron_right 18 chevron_right 19 chevron_right 20 chevron_right 21 chevron_right 22 chevron_right
Introduction
00:00 • 2min
How to Configure a Rack Without the Network
01:41 • 2min
The Importance of Simple Terminal UIs
03:57 • 5min
How to Demonstrate WICAT
08:40 • 4min
How to Replay a State Machine in a Debugger
12:45 • 3min
The Future of Debugability
15:18 • 2min
The Importance of Separating Out Your IO From Your Logic
17:39 • 4min
The Importance of Rust in the Workplace
21:54 • 2min
The Pain of Being a Parent of a Toddler
23:35 • 3min
How to Create a Visual State for Your Product
26:13 • 4min
How to Iterate Fast Onto Bugging
29:45 • 4min
The Role of Saturday in Deep Menued Systems
33:20 • 3min
How to Serialize and Deserialize Structures in Rust
36:04 • 2min
The Importance of Cerde in a Software Environment
38:18 • 2min
The Value of Flexibility in Distributed Systems
40:30 • 4min
How to Debug JavaScript in the Browser
44:58 • 5min
How to Make Distributed Systems Property Tests Deterministic
49:36 • 5min
PropTest: A Cool Tool
54:24 • 5min
The Last AA Debug
58:58 • 2min
The Importance of Horse Meat in Belgium
01:00:59 • 2min
The Importance of Experience in Software Development
01:03:28 • 1min
How to Build a Debugger in Amacron
01:04:56 • 3min
Andrew Stone of Oxide Engineering joined Bryan, Adam, and the Oxide Friends to talk about his purpose-built, replay debugger for the Oxide setup textual UI. Andrew borrowed a technique from his extensive work with distributed systems to built a UI that was well-structured... and highly amenable to debuggability. He built a custom debugger "in a weekend"!
Some of the topics we hit on, in the order that we hit them:
- tui-rs
- Crossterm
- The reedline crate
- Episode about the "Sidecar" switch
- Elm time-travel debugging
- Replay.io
- Devtools.fm episode on Replay.io
- AADEBUG conference
- California horse meat law
The (lightly) edited live chat from the show:
- MattCampbell: I'm gathering that this is more like the fancy pseudo-GUI style of TUI, which is possibly bad for accessibility
- ahl: we are also building with accessibility in mind, stripping away some of the non-textual elements optionally
- MattCampbell: oh, cool
- ahl: Episode about the "Sidecar" switch: https://github.com/oxidecomputer/oxide-and-friends/blob/master/2021_11_29.md
- MattCampbell: ooh! That kind of recording is definitely better for accessibility than a video.
- uwaces: Were you inspired by Elm? (The programming language for web browsers?)
- bcantrill: Here's Andrew's PR for this, FWIW: oxidecomputer/omicron#2682
- uwaces: Elm has a very similar model. They have even had a debugger that let you run events in reverse: https://elm-lang.org/news/time-travel-made-easy
- bch: I’m joining late - 1) does this state-machine replay model have a name 2) expand on (describe ) the I/o logic separation distinction?
- ahl: http://dtrace.org/blogs/ahl/2015/06/22/first-rust-program-pain/
- zk: RE: logic separation in consensus protocols: the benefit of seperating out the state machine into a side-effect free function allows you to write a formally verified implementation in a pure FP lang or theorem prover, and then extract a reference program from the proof.
- we're going to the zoo: lol i’m a web dev && we do UI tests via StorybookJS + snapshots of each story + snapshots of the end state of an interaction
- ig: At that point you could turn the recording into an “expect test”. https://blog.janestreet.com/the-joy-of-expect-tests/
- we're going to the zoo: TOFU but for tests 🥰
- uwaces: Are you at all worried that you are replicating the horror that is the IBM 3270 terminal? — I have personal history programming on z/OS where the only interface is a graphical EBCDIC 3027 interface — the horror is that people write programs to interact with graphical window (assuming a certain size).
- ahl: https://docs.rs/serde/latest/serde/#data-formats
- ahl: SHOW NOTES Bryan as "semi-elderly" engineer
- MattCampbell: didn't Bryan write a blog post on this?
- MattCampbell: http://dtrace.org/blogs/bmc/2008/11/16/on-modalities-and-misadventures/
- uwaces: https://www.replay.io
- ahl: https://devtools.fm/episode/9
- ahl: e.g. https://altsysrq.github.io/proptest-book/intro.html
- we're going to the zoo: https://github.com/AFLplusplus/LibAFL
- ig: Are you using proptest, quickcheck, or something else?
- nickik: This really started with Haskell https://hackage.haskell.org/package/QuickCheck Its also cool that it does 'narrowing' meaning it will try to find an error, and then try to generate a simpler error case.
- endigma: how different is something like this from what go calls "fuzzing"
- Riking: Fuzzing does also have a minimization step
- we're going to the zoo: https://github.com/dubzzz/fast-check
- Riking: Property-based testing tends to be structured differently in philosophy, while fuzzers are more aligned to "give you a bag of bytes"
- nickik: http://www.quviq.com/products/erlang-quickcheck/
- endigma: yeah I can tell its a different structure, but the overall goal seems similar
- we're going to the zoo: they are nonexclusive approaches to testing
- papertigers: I think Kelly was doing a bunch of tests at Joyent based on quick check and prop test. First time I encountered it
- we're going to the zoo: libafl provides a #[derive(Arbitrary)] macro that will provide the correct values for a struct
- uwaces: Lots of stuff in Rust existed first in Haskell (build.rs, quote!, Derive macros, Traits, ect….)…
- nixinator: https://tenor.com/view/%C3%B3culos-escuro-exterminador-terminator-arnold-schwarzenegger-gif-14440790
- we're going to the zoo: “what do these means” depends on who you ask lol
- we're going to the zoo: fast-check is 🔥 for TypeScript
- endigma: if the tested function is deterministic and the test is testing arbitrary input and testing against the result to be derivative in some way of the input function by some f(x), don't you end up re-implementing the tested function to provide the expected result? how does the author choose what properties of a system to test without falling into a "testing the test" pit?
- we're going to the zoo: Rust: “Here comes the Haskell plane!”
- nixinator: Isn’t rust == oxidation
- endigma: yes
- endigma: in a scientific sense
- nixinator: Iron oxide 🙂 lol
- nixinator: Very good!
- GeneralShaw: Is prop test a way of formal verification? Is it same/different?
- ahl: https://dl.acm.org/conference/aadebug
- ig: I mean, Haskell is an academic rese...